4. 스트림(Stream)

728x90

📌 스트림(Stream)
📌 파이프라인(Pipeline) 구성(.)
📌 스트림 생성, 중간 연산, 최종 연산
📌 Optional<T>
- ✔️ Optional

📌 스트림(Stream)

스트림(Stream)은 배열, 컬렉션의 저장 요소를 하나씩 참조해서 람다식으로 처리할 수 있도록 해주는 반복자이다.

스트림을 사용하면 List, Set, Map, 배열 등 다양한 데이터 소스로부터 스트림을 만들 수 있고, 이를 표준화된 방법으로 다룰 수 있다. 또한 데이터 소스를 다루는 풍부한 메서드를 제공한다. 이를 활용하면 다량의 데이터에 복잡한 연산을 수행하면서도, 가독성과 재사용성이 높은 코드를 작성할 수 있다.

✔️ 선언형으로 데이터 소스를 처리한다.

스트림을 이용하면 선언형으로 데이터 소스를 처리할 수 있다.

※ 선언형 프로그래밍이란?

프로그램을 “어떻게" 수행하는지보다는 “무엇을" 수행하는 지에 관심을 두는 프로그래밍 패러다임을 말한다.

명령형 방식에서는 하나하나의 절차를 따라가야만 코드를 이해할 수 있지만, 선언형 방식으로 코드를 작성하면 내부 동작 원리를 모르더라도 코드가 무슨 일을 하는지 이해할 수 있다. 즉, “어떻게" 라는 영역은 추상화되어 있다.

자바 7 이전까지는 List 컬렉션에서 요소를 순차적으로 처리하기 위해 다음과 같이 사용해왔다.

 import java.util.List;
 
public class ImperativeProgrammingExample {
    public static void main(String[] args){
        // List에 있는 숫자들 중에서 4보다 큰 짝수의 합계 구하기
        List<Integer> numbers = List.of(1, 3, 6, 7, 8, 11);
        int sum = 0;
 
        for(int number : numbers){
            if(number > 4 && (number % 2 == 0)){
                sum += number;
            }
        }
 
        System.out.println("# 명령형 프로그래밍 : " + sum);
    }
}

이 코드를 Stream을 사용해서 변경하면 다음과 같다.

 import java.util.List;
 
public class DeclarativeProgramingExample {
    public static void main(String[] args){
        // List에 있는 숫자들 중에서 4보다 큰 짝수의 합계 구하기
        List<Integer> numbers = List.of(1, 3, 6, 7, 8, 11);
 
        int sum =
                numbers.stream()
                        .filter(number -> number > 4 && (number % 2 == 0))
                        .mapToInt(number -> number)
                        .sum();
 
        System.out.println("# 선언형 프로그래밍: " + sum);
    }
}

for문을 사용한 코드와 Stream을 사용한 코드를 비교해보면 Stream을 사용하는 것이 훨씬 단순하고 가독성이 높음을 알 수 있다.

✔️ 람다식으로 요소 처리 코드를 제공한다.

Stream이 제공하는 대부분의 요소 처리 메서드는 함수형 인터페이스 매개타입을 가지기 때문에 람다식 또는 메서드 참조를 이용해서 요소 처리 내용을 매개 값으로 전달할 수 있다.

아래의 예제 코드를 살펴보자.

 //Student.java
public class Student {
    private String name;
    private int score;
 
    public Student(String name, int score){
        this.name = name;
        this.score = score;
    }
 
    public String getName(){
        return name;
    }
 
    public int getScore(){
        return score;
    }
}

 import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
 
public class StreamLambdaExample {
    public static void main(String[] args) throws Exception {
        List<Student> list = Arrays.asList(
            new Student("김코딩", 95),
            new Student("이자바", 92)
        );
 
        Stream<Student> stream = list.stream();
        stream.forEach( s -> {
            String name = s.getName();
            int score = s.getScore();
            System.out.println(name+ " - " +score);
        });
    }
}
/*
김코딩 - 95
이자바 - 92
*/

위 예제는 컬렉션에 저장된 Student를 하나씩 가져와 학생 이름과 성적을 콘솔에 출력하도록 forEach()메서드에 매개값으로 람다식을 주는 코드이다. stream() 메서드를 사용해 Collection(List)을 Stream 타입으로 만들어줄 수 있다.

✔️ 내부 반복자를 사용하므로 병렬 처리가 쉽다.

외부 반복자(external iterator)란 개발자가 코드로 직접 컬렉션의 요소를 반복해서 가져오는 코드 패턴을 말한다.

index를 사용하는 for문, iterator를 이용하는 while문은 모두 외부 반복자를 이용한 형태이다.

반면에,

내부 반복자(internal iterator)는 컬렉션 내부에서 요소들을 반복시키고 개발자는 요소 당 처리해야할 코드만 제공하는 코드 패턴을 말한다.

내부 반복자를 사용해서 얻는 이점은 컬렉션 내부에서 어떻게 요소를 반복시킬 것인가는 컬렉션에게 맡겨두고, 개발자는 요소 처리 코드에만 집중할 수 있다는 점이다.

내부 반복자는 요소들의 반복 순서를 변경하거나 멀티 코어 CPU를 최대한 활용하기 위해 요소들을 분배시켜 병렬 작업을 할 수 있게 도와주기 때문에 하나씩 처리하는 순차적 외부 반복자보다 효율적으로 요소를 반복시킬 수 있다.

(병렬 스트림을 사용하기 위해서는 스트림의 parallel() 메서드를 사용하면 된다)

Iterator는 컬렉션의 요소를 가져오는 것에서부터 처리하는 것까지 모두 개발자가 작성해야 하지만 스트림은 람다식으로 요소 처리 내용만 전달할 뿐, 반복은 컬렉션 내부에서 이루어진다.

※ 병렬 처리(Parallel Processing)

한 가지 작업을 서브 작업으로 나누고, 서브 작업들을 분리된 스레드에서 병렬적으로 처리하는 것을 의미한다.

✔️ 중간 연산과 최종 연산을 할 수 있다.

스트림은 컬렉션의 요소에 대해 중간 연산과 최종 연산을 수행할 수 있다.

중간 연산에서는 매핑, 필터링, 정렬 등을 수행하고 최종 연산에서는 반복, 카운팅, 평균, 총합 등의 집계를 수행할 수 있다. 예를 들어 학생 객체를 요소로 가지는 컬렉션이 있다고 가정하면, 중간 연산에서는 학생의 점수를 뽑아내고, 최종 연산에서는 점수의 평균 값을 산출할 수 있다.

📌 파이프라인(Pipeline) 구성(.)

파이프라인(Pipeline)은 여러개의 스트림이 연결되어 있는 구조를 의미한다.

스트림은 데이터의 필터링, 매핑, 정렬, 그루핑 등의 중간 연산과 합계, 평균, 카운팅, 최대 / 최소 값 등의 최종 연산을 파이프라인(pipelines)으로 해결한다. 파이프라인에서 최종 연산을 제외하고는 모두 중간 연산 스트림이다.

이러한 대량의 데이터를 가공해서 축소하는 것을 일반적으로 리덕션(Reduction)이라고 한다.

데이터의 합계, 평균 값, 카운팅, 최소값, 최대 값 등이 대표적인 리덕션의 결과물이라고 볼 수 있다. 그러나 컬렉션 요소를 리덕션 결과물로 바로 집계할 수 없을 때에는 필터, 매핑, 정렬, 그룹화 등의 중간 연산이 필요하다.

중간 스트림이 생성될 때 요소들이 바로 중간 연산(필터링, 매핑, 정렬)되는 것이 아니라 최종 연산이 시작되기 전까지는 지연된다. 최종 연산이 시작되면 비로소 컬렉션의 요소가 하나씩 중간 스트림에서 연산되고 최종 연산까지 오게 된다.

Stream 인터페이스에는 필터링, 매핑, 정렬 등의 많은 중간 연산 메서드가 있는데, 이 메서드들은 중간 연산된 스트림을 리턴한다. 그리고 이 스트림에서 다시 중간 연산 메서드를 호출해서 파이프라인을 형성하게 된다.

예를 들어 회원 컬렉션에서 남자만 필터링하는 중간 스트림을 연결하고, 다시 나이로 매핑하는 스트림을 연결한 후, 최종적으로 평균 나이를 집계한다면 다음 그림처럼 파이프라인이 형성되게 된다.

해당 파이프라인을 코드로 표현하자면 다음과 같다.

 Stream<Member> maleFemaleStream = list.stream();
Stream<Member> maleStream = maleFemaleSTream.filter(m -> m.getGender() == Member.MALE);
IntStream ageStream = maleStream.mapToInt(Member::getAge);
OptionalDouble opd = ageStream.average();
double ageAve = opd.getAsDouble();

.filter(m → m.getGender() == Member.MALE)은 Member 객체를 요소로 하는 새로운 스트림을 생성한다.
.mapToInt(Member::getAge)는 Member 객체를 age 값으로 매핑해서 age를 요소로 하는 새로운 스트림을 생성한다.
average()메소드는 age 요소의 평균을 OptionalDouble에 저장한다.
OptionalDouble에 저장된 평균 값을 읽기 위해 getAsDouble()메소드를 호출한다.

위 코드에서 로컬 변수를 생략하고 연결하면 다음과 같은 형태의 파이프라인 코드만 남는다.

 double ageAve = list.stream() //오리지널 스트림
.filter(m-> m.getGender() == Member.MALE) //중간 연산 스트림
.mapToInt(Member::getAge) //중간 연산 스트림
.average() //최종 연산
.getAsDouble();

📌 스트림 생성, 중간 연산, 최종 연산

스트림은 본래 “흐름", “연속"을 의미한다. 자바의 스트림 또한 데이터를 연속적으로 전달하는 통로라고 말할 수 있다.

✔️ 스트림의 생성

Collection 인터페이스에는 stream()이 정의되어 있기 때문에, Collection 인터페이스를 구현한 객체들(List, Set 등)은 모두 이 메서드를 이용해 스트림을 생성할 수 있다.

stream()을 사용하면 해당 Collection의 객체를 소스로 하는 Stream을 반환한다.

 // List로부터 스트림을 생성
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> listStream = list.stream();
listStream.forEach(System.out::prinln); //스트림의 모든 요소를 출력.

배열의 원소들을 소스로 하는 Stream을 생성하기 위해서는 Stream의 of 메서드 또는 Arrays의 stream 메서드를 사용한다.

 // 배열로부터 스트림을 생성
Stream<String> stream = Stream.of("a", "b", "c"); //가변인자
Stream<String> stream = Stream.of(new String[] {"a", "b", "c"});
Stream<String> stream = Arrays.stream(new String[] {"a", "b", "c"});
Stream<String> stream = Arrays.stream(new String[] {"a", "b", "c"}, 0, 3); //end 범위 미포함

위와 같이 객체를 위한 Stream 외에도 int와 long, 그리고 double과 같은 원시 자료형들을 사용하기 위한 특수한 종류의

Stream(IntStream, LongStream, DoubleStream)들도 사용할 수 있으며, IntStream은 range() 메서드를 사용하여 기존의 for문을 대체할 수 있다.

 // 4이상 10미만의 숫자를 갖는 IntStream
IntStream stream = IntStream.range(4, 10);

스트림은 주로 컬렉션과 배열에서 얻지만, 다음과 같은 소스로부터 스트림 구현 객체를 얻을 수도 있다.

리턴 타입	메서드(매개 변수)	소스
Stream	java.util.Collection.Stream(), java.util.Collection.parallelSream( )	컬렉션
Stream, IntStream, LongStream, DoubleStream	Arrays.stream(T[]), Arrays.stream(int[]), Arrays.stream(long[]), Arrays.stream(double[]), Stream.of(T[]), IntStream.of(int[]) LongStream.of(long[]), DoubleStream.of(double[])	배열
IntStream	IntStream.range(int, int), IntStream.rangeClosed(int, int)	int 범위
LongStream	LongStream.range(long, long), LongStream.rangeClosed(long, long)	long 범위

❗️스트림 사용 시 주의할 점

스트림은 데이터 소스로부터 데이터를 읽기만 할 뿐 변경하지 않는다. (Read-Only)
스트림은 일회용이다. 한 번 사용하면 닫히므로, 필요하다면 새로운 스트림을 만들어야 한다.(One-Time-Only)

✔️ 중간 연산

중간 연산은 연산 결과를 스트림으로 반환하기 때문에, 여러 번 수행할 수 있다.

 Stream
    .of(1,2,3,4)                          // 데이터 소스(Data Source)
    .filter(n -> n % 2 != 0)              //
    .map(n -> n * 2)                      // 중간 연산(Intermediate Operation)
    .forEach(n -> System.out.println(n)); // 최종 연산(Terminal Operation)

❗️필터링(filter, distinct)

filter()

⌲ Stream에서 조건에 맞는 데이터만을 정제하여 더 작은 컬렉션을 만든다.

⌲ filter() 메서드에는 조건(Predicate)이 주어지고, 조건이 참이 되는 요소만 필터링한다.

distinct()

⌲ Stream의 요소들에 중복된 데이터가 존재하는 경우, 중복을 제거하기 위해 사용한다.

 import java.util.Arrays;
import java.util.List;
 
public class FilteringExample {
    public static void main(String[] args) throws Exception {
        List<String> names = Arrays.asList("김코딩", "이자바", "김인기", "김코딩");
 
        names.stream()
             .distinct() //중복제거
             .forEach(n -> System.out.println(n));
        System.out.println();
 
        names.stream()
             .filter(n -> n.startsWith("김")) //필터링
             .forEach(n -> System.out.println(n));
        System.out.println();
 
        names.stream()
             .distinct() //중복제거
             .filter(n -> n.startsWith("김")) //필터링
             .forEach(n -> System.out.println(n));
    }
}
/*
김코딩
이자바
김인기
 
김코딩
김인기
김코딩
 
김코딩
김인기
*/

❗️매핑(map, flatMap)

map()

⌲ map은 기존의 Stream 요소들을 대체하는 요소로 구성된 새로운 Stream을 형성하는 연산이다.

 List<String> names = Arrays.asList("kimcoding", "javalee", "ingikim", "kimcoding");
    names.stream()
				 .map(s -> s.toUpperCase())
				 .forEach(n->System.out.println(n));
/*
KIMCODING
JAVALEE
INGIKIM
KIMCODING
*/

⌲ map() 이외에도 mapToInt(), mapToLong(), mapToDouble() 등의 메서드가 있다.

⌲ map() 메서드는 작업을 하다 보면 일반적인 Stream 객체를 원시 Stream으로 바꾸거나 그 반대로 하는 작업이 필요한 경우 사용된다.

⌲ 반대로 원시 객체는 mapToObject()를 통해 일반적인 Stream 객체로 바꿀 수 있다.

flatMap()

⌲ 요소를 대체하는 복수 개의 요소들로 구성된 새로운 스트림을 리턴한다.

⌲ 저장된 값을 특정한 형태로 변환하는데 주로 사용되며, Java에서는 map 함수의 인자로 함수형 인터페이스 function을 받는다. 예를 들어 String을 요소들로 갖는 Stream을 모두 대문자 String 요소들로 변환하고자 할 때 map을 이용할 수 있다.

map()과 flatMap() 차이점

⌲ map()은 스트림의 스트림을 반환하는 반면, flatMap()은 스트림을 반환한다.

❗️정렬(sorted)

⌲ Stream의 요소들을 정렬하기 위해서는 sorted를 사용해야 하며, 파라미터로 Comparator를 넘길 수도 있다.

⌲ Comparator 인자 없이 호출할 경우에는 오름차순으로 정렬이 되며, 내림차순으로 정렬하기 위해서는 Comparator의 reverseOrder를 이용한다.

 List<String> list = Arrays.asList("Java", "Scala", "Groovy", "Python", "Go", "Swift");
 
        list.stream()
            .sorted()
            .forEach(n -> System.out.println(n));
        System.out.println();
 
/*
Go, Groovy, Java, Python, Scala, Swift
*/
        list.stream()
            .sorted(Comparator.reverseOrder())
            .forEach(n -> System.out.println(n));
 
/*
Swift, Scala, Python, Java, Groovy, Go
*/

⌲ Comparable을 기본적으로 구현한 클래스가 아니라면, 다음과 같이 comparing() 메서드를 사용해 비교할 수 있다.

 import java.lang.*;
import java.util.*;
import java.util.stream.Stream;
 
class Employee implements Comparable<Employee>{
    int id;
    String name,department;
 
    public Employee(int id, String name, String department) {
        this.id = id;
        this.name = name;
        this.department = department;
    }
 
    String getName() {
        return name;
    }
    int getId() {
        return id;
    }
    String getDepartment() {
        return department;
    }
    public String toString() {
        return String.format("[%d, %s, %s]", id, name, department);
    }
    public int compareTo(Employee e) {
        return e.id - this.id;
    }
 
}
 
class ComparatorExample {
    public static void main(String[] args) {
        Stream<Employee> workersStream =
                Stream.of(new Employee(11, "Kim Coding", "Software Engineering"),
                new Employee(5, "Hello World", "Growth Marketing"),
                new Employee(7, "Park Hacker", "Software Engineering"));
        workersStream.sorted(Comparator.comparing(Employee::getId)).forEach(System.out::println);
 
    }
}

❗️연산 결과 확인(peek)

peek()

⌲ forEach()와 동일하게 요소를 하나씩 돌면서 출력하지만, peek()은 연산 중간에 결과를 확인하여 디버깅하고자 할 때 사용된다. (forEach()는 최종 연산자다)

 intStream
	.filter(a -> a%2 ==0)
	.peek(n-> System.out.println(n))
	.sum();

✔️ 최종 연산

최종 연산은 연산 결과가 스트림이 아니므로, 한 번만 연산이 가능하다.

❗️연산 결과 확인(forEach)

forEach()

⌲ 최종 연산 메서드이기 때문에 파이프라인 마지막에서 요소를 하나씩 연산한다.

⌲ forEach 값을 출력할 때도 사용하지만, 이메일 발송, 스케줄링 등 리턴 값이 없는 작업에서도 많이 사용된다.

 intStream
	.filter(a -> a%2 ==0)
	.forEach(n -> System.out.println(n));

❗️매칭(match)

match()

⌲ Stream의 요소들이 특정한 조건을 충족하는지 검사하고 싶은 경우에는 match() 메서드를 이용할 수 있다.

⌲ match() 메서드는 크게 3가지가 있다.

allMatch() : 모든 요소들이 매개 값으로 주어진 Predicate의 조건을 만족하는지 조사
anyMatch() : 최소한 한 개의 요소가 매개 값으로 주어진 Predicate의 조건을 만족하는지 조사
noneMatch() : 모든 요소들이 매개 값으로 주어진 Predicate의 조건을 만족하지 않는지 조사

 import java.util.Arrays;
 
public class MatchesExample {
    public static void main(String[] args) throws Exception {
        int[] intArr = {2,4,6};
        boolean result = Arrays.stream(intArr).allMatch(a->a%2==0);
        System.out.println("모두 2의 배수인가? " + result);
 
        result = Arrays.stream(intArr).anyMatch(a->a%3==0);
        System.out.println("하나라도 3의 배수가 있는가? " + result);
 
        result = Arrays.stream(intArr).noneMatch(a->a%3==0);
        System.out.println("3의 배수가 없는가? " + result);
    }
}
 
/*
모두 2의 배수인가? true
하나라도 3의 배수가 있는가? true
3의 배수가 없는가? false
*/

❗️기본 집계(sum, count, average, max, min)

⌲ 집계는 최종 연산 기능으로, 요소들을 카운팅, 합계, 평균 값, 최대 값, 최소 값 등으로 연산하여 하나의 값으로 산출하는 것을 의미한다.

 import java.util.Arrays;
 
public class AggregateExample {
    public static void main(String[] args) throws Exception {
        int[] intArr = {1,2,3,4,5};
 
        long count = Arrays.stream(intArr).count();
        System.out.println("intArr의 전체 요소 개수 " + count);
 
        long sum = Arrays.stream(intArr).sum();
        System.out.println("intArr의 전체 요소 합 " + sum);
 
        double avg = Arrays.stream(intArr).average().getAsDouble();
        System.out.println("전체 요소의 평균값 " + avg);
 
        int max = Arrays.stream(intArr).max().getAsInt();
        System.out.println("최대값 " + max);
 
        int min = Arrays.stream(intArr).min().getAsInt();
        System.out.println("최소값 " + min);
 
        int first = Arrays.stream(intArr).findFirst().getAsInt();
        System.out.println("배열의 첫번째 요소 " + first);
 
    }
}
 
/*
intArr의 전체 요소 개수 5
intArr의 전체 요소 합 15
전체 요소의 평균값 3.0
최대값 5
최소값 1
배열의 첫번째 요소 1
*/

❗️reduce

⌲ 앞서 본 집계 메서드 외에도 다양한 집계 결과물을 만들 수 있는 reduce 메서드가 있다.

⌲ reduce는 값을 누적하여 하나로 응축(reduce)하는 방식으로 동작한다.

⌲ 앞의 두 요소의 연산 결과를 바탕으로 다음 요소와 연산한다.

⌲ reduce 메서드는 최대 3개의 매개변수를 받을 수 있다.

Accumulator: 각 요소를 계산한 중간 결과를 생성하기 위해 사용
Identity: 계산을 수행하기 위한 초기값
Combiner: 병렬 스트림(Parlallel Stream)에서 나누어 계산된 결과를 하나로 합치기 위한 로직

❗️collect

⌲ Stream의 요소들을 List나 Set, Map 등 다른 종류의 결과로 수집하고 싶은 경우 사용한다.

⌲ collect 메서드는 어떻게 Stream의 요소들을 수집할 것인가를 정의한 Collector 타입을 인자로 받는다. 이는 Collector 인터페이스를 구현한 클래스이다.

 //Student.java
public class Student {
    public enum Gender {Male, Female};
    private String name;
    private int score;
    private Gender gender;
 
    public Student(String name, int score, Gender gender) {
        this.name = name;
        this.score = score;
        this.gender = gender;
    }
 
    public Gender getGender(){
        return gender;
    }
 
    public String getName(){
        return name;
    }
 
    public int getScore(){
        return score;
    }
}

 //CollectExample.java
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
 
public class CollectExample {
    public static void main(String[] args) throws Exception {
        List<Student> totalList = Arrays.asList(
            new Student("김코딩", 10, Student.Gender.Male),
            new Student("김인기", 8, Student.Gender.Male),
            new Student("이자바", 9, Student.Gender.Female),
            new Student("최민선", 10, Student.Gender.Female)
        );
 
        List<Student> maleList = totalList.stream()
        .filter(s -> s.getGender() == Student.Gender.Male)
        .collect(Collectors.toList());
 
        maleList.stream().forEach(n->System.out.println(n.getName()));
 
        Set<Student> femaleSet = totalList.stream()
        .filter(s -> s.getGender() == Student.Gender.Female)
        .collect(Collectors.toCollection(HashSet :: new));
 
        femaleSet.stream().forEach(n->System.out.println(n.getName()));
    }
}

📌 Optional<T>

Optional은 NullPointerException(NPE), 즉 null 값으로 인해 에러가 발생하는 현상을 객체 차원에서 효율적으로 방지하고자 도입되었다.

연산 결과를 Optional에 담아서 반환하면, 따로 조건문을 작성해주지 않아도 NPE가 발생하지 않도록 코드를 작성할 수 있다.

✔️ Optional

Optional 클래스는 모든 타입의 객체를 담을 수 있는 래퍼(Wrapper) 클래스이다.

 public final class Optional<T> {
	private final T value; // T타입의 참조변수
}

Optional 객체를 생성하려면 of() 또는 ofNullable()을 사용한다.

참조변수의 값이 null일 가능성이 있다면, ofNullable()을 사용한다.

 Optional<String> opt1 = Optional.ofNullable(null);
Optional<String> opt2 = Optional.ofNullable("123");
System.out.println(opt1.isPresent()); //Optional 객체의 값이 null인지 여부를 리턴합니다.
System.out.println(opt2.isPresent());

Optional 타입의 참조변수를 기본 값으로 초기화하려면 empty() 메서드를 사용한다.

Optional<String> opt3 = Optional.<String>empty();

Optional 객체에 저장된 값을 가져오려면 get()을 사용한다.

참조변수의 값이 null일 가능성이 있다면 orElse()메서드를 사용해 디폴트 값을 지정해줄 수 있다.

 Optional<String> optString = Optional.of("codestates");
System.out.println(optString);
System.out.println(optString.get());
 
String nullName = null;
String name = Optional.ofNullable(nullName).orElse("kimcoding");
System.out.println(name);

Optional 객체는 스트림과 유사하게 여러 메서드를 연결해서 작성할 수 있다.(메서드 체이닝)

 import java.util.Arrays;
import java.util.List;
import java.util.Optional;
 
public class OptionalExample {
    public static void main(String[] args) {
        List<String> languages = Arrays.asList(
                "Ruby", "Python", "Java", "Go", "Kotlin");
        Optional<List<String>> listOptional = Optional.of(languages);
 
        int size = listOptional
                .map(List::size)
                .orElse(0);
        System.out.println(size);
    }
}

Optional 객체에서 제공하는 전체 메서드는 공식문서를 참고하자.

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`

오늘도 런캣은 달린다

4. 스트림(Stream) - Java 8

📌 스트림(Stream)

✔️ 선언형으로 데이터 소스를 처리한다.

✔️ 람다식으로 요소 처리 코드를 제공한다.

✔️ 내부 반복자를 사용하므로 병렬 처리가 쉽다.

✔️ 중간 연산과 최종 연산을 할 수 있다.

📌 파이프라인(Pipeline) 구성(.)

📌 스트림 생성, 중간 연산, 최종 연산

✔️ 스트림의 생성

✔️ 중간 연산

✔️ 최종 연산

📌 Optional<T>

✔️ Optional

댓글

티스토리툴바

개인정보

단축키

내 블로그

블로그 게시글

모든 영역

	import java.util.List;

	public class ImperativeProgrammingExample {
	public static void main(String[] args){
	// List에 있는 숫자들 중에서 4보다 큰 짝수의 합계 구하기
	List<Integer> numbers = List.of(1, 3, 6, 7, 8, 11);
	int sum = 0;

	for(int number : numbers){
	if(number > 4 && (number % 2 == 0)){
	sum += number;
	}
	}

	System.out.println("# 명령형 프로그래밍 : " + sum);
	}
	}

	import java.util.List;

	public class DeclarativeProgramingExample {
	public static void main(String[] args){
	// List에 있는 숫자들 중에서 4보다 큰 짝수의 합계 구하기
	List<Integer> numbers = List.of(1, 3, 6, 7, 8, 11);

	int sum =
	numbers.stream()
	.filter(number -> number > 4 && (number % 2 == 0))
	.mapToInt(number -> number)
	.sum();

	System.out.println("# 선언형 프로그래밍: " + sum);
	}
	}

	//Student.java
	public class Student {
	private String name;
	private int score;

	public Student(String name, int score){
	this.name = name;
	this.score = score;
	}

	public String getName(){
	return name;
	}

	public int getScore(){
	return score;
	}
	}

	import java.util.Arrays;
	import java.util.List;
	import java.util.stream.Stream;

	public class StreamLambdaExample {
	public static void main(String[] args) throws Exception {
	List<Student> list = Arrays.asList(
	new Student("김코딩", 95),
	new Student("이자바", 92)
	);

	Stream<Student> stream = list.stream();
	stream.forEach( s -> {
	String name = s.getName();
	int score = s.getScore();
	System.out.println(name+ " - " +score);
	});
	}
	}
	/*
	김코딩 - 95
	이자바 - 92
	*/

	Stream<Member> maleFemaleStream = list.stream();
	Stream<Member> maleStream = maleFemaleSTream.filter(m -> m.getGender() == Member.MALE);
	IntStream ageStream = maleStream.mapToInt(Member::getAge);
	OptionalDouble opd = ageStream.average();
	double ageAve = opd.getAsDouble();

	double ageAve = list.stream() //오리지널 스트림
	.filter(m-> m.getGender() == Member.MALE) //중간 연산 스트림
	.mapToInt(Member::getAge) //중간 연산 스트림
	.average() //최종 연산
	.getAsDouble();

	// List로부터 스트림을 생성
	List<String> list = Arrays.asList("a", "b", "c");
	Stream<String> listStream = list.stream();
	listStream.forEach(System.out::prinln); //스트림의 모든 요소를 출력.

	// 배열로부터 스트림을 생성
	Stream<String> stream = Stream.of("a", "b", "c"); //가변인자
	Stream<String> stream = Stream.of(new String[] {"a", "b", "c"});
	Stream<String> stream = Arrays.stream(new String[] {"a", "b", "c"});
	Stream<String> stream = Arrays.stream(new String[] {"a", "b", "c"}, 0, 3); //end 범위 미포함

	// 4이상 10미만의 숫자를 갖는 IntStream
	IntStream stream = IntStream.range(4, 10);

	Stream
	.of(1,2,3,4) // 데이터 소스(Data Source)
	.filter(n -> n % 2 != 0) //
	.map(n -> n * 2) // 중간 연산(Intermediate Operation)
	.forEach(n -> System.out.println(n)); // 최종 연산(Terminal Operation)

	import java.util.Arrays;
	import java.util.List;

	public class FilteringExample {
	public static void main(String[] args) throws Exception {
	List<String> names = Arrays.asList("김코딩", "이자바", "김인기", "김코딩");

	names.stream()
	.distinct() //중복제거
	.forEach(n -> System.out.println(n));
	System.out.println();

	names.stream()
	.filter(n -> n.startsWith("김")) //필터링
	.forEach(n -> System.out.println(n));
	System.out.println();

	names.stream()
	.distinct() //중복제거
	.filter(n -> n.startsWith("김")) //필터링
	.forEach(n -> System.out.println(n));
	}
	}
	/*
	김코딩
	이자바
	김인기

	김코딩
	김인기
	김코딩

	김코딩
	김인기
	*/

	List<String> names = Arrays.asList("kimcoding", "javalee", "ingikim", "kimcoding");
	names.stream()
	.map(s -> s.toUpperCase())
	.forEach(n->System.out.println(n));
	/*
	KIMCODING
	JAVALEE
	INGIKIM
	KIMCODING
	*/

	List<String> list = Arrays.asList("Java", "Scala", "Groovy", "Python", "Go", "Swift");

	list.stream()
	.sorted()
	.forEach(n -> System.out.println(n));
	System.out.println();

	/*
	Go, Groovy, Java, Python, Scala, Swift
	*/
	list.stream()
	.sorted(Comparator.reverseOrder())
	.forEach(n -> System.out.println(n));

	/*
	Swift, Scala, Python, Java, Groovy, Go
	*/

	import java.lang.*;
	import java.util.*;
	import java.util.stream.Stream;

	class Employee implements Comparable<Employee>{
	int id;
	String name,department;

	public Employee(int id, String name, String department) {
	this.id = id;
	this.name = name;
	this.department = department;
	}

	String getName() {
	return name;
	}
	int getId() {
	return id;
	}
	String getDepartment() {
	return department;
	}
	public String toString() {
	return String.format("[%d, %s, %s]", id, name, department);
	}
	public int compareTo(Employee e) {
	return e.id - this.id;
	}

	}

	class ComparatorExample {
	public static void main(String[] args) {
	Stream<Employee> workersStream =
	Stream.of(new Employee(11, "Kim Coding", "Software Engineering"),
	new Employee(5, "Hello World", "Growth Marketing"),
	new Employee(7, "Park Hacker", "Software Engineering"));
	workersStream.sorted(Comparator.comparing(Employee::getId)).forEach(System.out::println);

	}
	}

	intStream
	.filter(a -> a%2 ==0)
	.peek(n-> System.out.println(n))
	.sum();

	import java.util.Arrays;

	public class MatchesExample {
	public static void main(String[] args) throws Exception {
	int[] intArr = {2,4,6};
	boolean result = Arrays.stream(intArr).allMatch(a->a%2==0);
	System.out.println("모두 2의 배수인가? " + result);

	result = Arrays.stream(intArr).anyMatch(a->a%3==0);
	System.out.println("하나라도 3의 배수가 있는가? " + result);

	result = Arrays.stream(intArr).noneMatch(a->a%3==0);
	System.out.println("3의 배수가 없는가? " + result);
	}
	}

	/*
	모두 2의 배수인가? true
	하나라도 3의 배수가 있는가? true
	3의 배수가 없는가? false
	*/

	import java.util.Arrays;

	public class AggregateExample {
	public static void main(String[] args) throws Exception {
	int[] intArr = {1,2,3,4,5};

	long count = Arrays.stream(intArr).count();
	System.out.println("intArr의 전체 요소 개수 " + count);

	long sum = Arrays.stream(intArr).sum();
	System.out.println("intArr의 전체 요소 합 " + sum);

	double avg = Arrays.stream(intArr).average().getAsDouble();
	System.out.println("전체 요소의 평균값 " + avg);

	int max = Arrays.stream(intArr).max().getAsInt();
	System.out.println("최대값 " + max);

	int min = Arrays.stream(intArr).min().getAsInt();
	System.out.println("최소값 " + min);

	int first = Arrays.stream(intArr).findFirst().getAsInt();
	System.out.println("배열의 첫번째 요소 " + first);

	}
	}

	/*
	intArr의 전체 요소 개수 5
	intArr의 전체 요소 합 15
	전체 요소의 평균값 3.0
	최대값 5
	최소값 1
	배열의 첫번째 요소 1
	*/

	//Student.java
	public class Student {
	public enum Gender {Male, Female};
	private String name;
	private int score;
	private Gender gender;

	public Student(String name, int score, Gender gender) {
	this.name = name;
	this.score = score;
	this.gender = gender;
	}

	public Gender getGender(){
	return gender;
	}

	public String getName(){
	return name;
	}

	public int getScore(){
	return score;
	}
	}

	//CollectExample.java
	import java.util.Arrays;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Set;
	import java.util.stream.Collectors;

	public class CollectExample {
	public static void main(String[] args) throws Exception {
	List<Student> totalList = Arrays.asList(
	new Student("김코딩", 10, Student.Gender.Male),
	new Student("김인기", 8, Student.Gender.Male),
	new Student("이자바", 9, Student.Gender.Female),
	new Student("최민선", 10, Student.Gender.Female)
	);

	List<Student> maleList = totalList.stream()
	.filter(s -> s.getGender() == Student.Gender.Male)
	.collect(Collectors.toList());

	maleList.stream().forEach(n->System.out.println(n.getName()));

	Set<Student> femaleSet = totalList.stream()
	.filter(s -> s.getGender() == Student.Gender.Female)
	.collect(Collectors.toCollection(HashSet :: new));

	femaleSet.stream().forEach(n->System.out.println(n.getName()));
	}
	}

	public final class Optional<T> {
	private final T value; // T타입의 참조변수
	}

4. 스트림(Stream) - Java 8

📌 스트림(Stream)

✔️ 선언형으로 데이터 소스를 처리한다.

✔️ 람다식으로 요소 처리 코드를 제공한다.

✔️ 내부 반복자를 사용하므로 병렬 처리가 쉽다.

✔️ 중간 연산과 최종 연산을 할 수 있다.

📌 파이프라인(Pipeline) 구성(.)

📌 스트림 생성, 중간 연산, 최종 연산

✔️ 스트림의 생성

✔️ 중간 연산

✔️ 최종 연산

📌 Optional<T>

✔️ Optional

관련글

댓글

티스토리툴바

개인정보

단축키

내 블로그

블로그 게시글

모든 영역

	Optional<String> opt1 = Optional.ofNullable(null);
	Optional<String> opt2 = Optional.ofNullable("123");
	System.out.println(opt1.isPresent()); //Optional 객체의 값이 null인지 여부를 리턴합니다.
	System.out.println(opt2.isPresent());

	Optional<String> optString = Optional.of("codestates");
	System.out.println(optString);
	System.out.println(optString.get());

	String nullName = null;
	String name = Optional.ofNullable(nullName).orElse("kimcoding");
	System.out.println(name);

	import java.util.Arrays;
	import java.util.List;
	import java.util.Optional;

	public class OptionalExample {
	public static void main(String[] args) {
	List<String> languages = Arrays.asList(
	"Ruby", "Python", "Java", "Go", "Kotlin");
	Optional<List<String>> listOptional = Optional.of(languages);

	int size = listOptional
	.map(List::size)
	.orElse(0);
	System.out.println(size);
	}
	}