스트림의 최종 연산

[최종 연산이란?]

1. 연산 결과가 스트림이 아닌 연산

2. 스트림의 요소를 소모하므로 단 한 번만 적용이 가능하다.

 

[최종 연산 종류]

1. 스트림의 모든 요소에 지정된 작업을 수행 – forEach( ), forEachOrdered( )

// 스트림 요소에 작업 수행(스트림을 소비O)
void forEach(Consumer<? super T>action) // 병렬스트림인 경우 순서가 보장되지 않음

// 병렬스트림에서 순서를 유지하면서 작업을 수행할 때 사용
void forEachOrdered(Consumer<? super T>action) // 병렬스트림인 경우에도 순서가 보장됨

// 예시1. 스트림 작업을 직렬로 처리. 스트림은 기본적으로 직렬 처리
IntStream.range(1, 10).sequential().forEach(System.out::print); // 123456789
IntStream.range(1, 10).sequential().forEachOrdered(System.out::print); // 123456789

// 예시2. 스트림 작업을 병렬로 처리
IntStream.range(1, 10).parallel().forEach(System.out::print); // 683295714
IntStream.range(1, 10).parallel().forEachOrdered(System.out::print); // 123456789

 

2. 조건 검사 – allMatch( ), anyMatch( ), noneMatch( )

// 모든 요소가 조건을 만족시키면 true
boolean allMatch (Predicate<? super T> predicate)
 
// 한 요소라도 조건을 만족시키면 true
boolean anyMatch (Predicate<? super T> predicate)
 
// 모든 요소가 조건을 만족시키지 않으면 true
boolean noneMatch(Predicate<? super T> predicate)

// 예시
boolean hasFailedStu = stuStream.anyMatch(s-> s.getTotalScore()<=100);
                                      // 총점이 100점 이하인 낙제자가 있는지 확인

 

3. 조건에 일치하는 요소 찾기 – findFirst( ) , findAny( )

Optional<T> findFirst() // 첫 번째 요소를 반환. 직렬 스트림에 사용
Optional<T> findAny() // 아무거나 하나를 반환. 병렬 스트림에 사용
// 결과가 null일 수 있기 때문에 Optional 객체로 반환

// 예시. 보통 필터와 함께 쓰임
Optional<Student> result = stuStream.filter(s-> s.getTotalScore() <= 100).findFirst();
Optional<Student> result = parallelStream.filter(s-> s.getTotalScore() <= 100).findAny();

 

4. 스트림의 요소를 하나씩 줄여가며 누적연산 수행 – reduce( )

// 누적연산(accumulator)을 하는 최종 연산의 핵심1
Optional<T> reduce(BinaryOperator<T> accumulator)
T reduce(T identity, BinaryOperator<T> accumulator) // 위의 것과 같음
U reduce(U identity, BiFunction<U,T,U> accumulator, BinaryOperator<U> combiner)
// identity - 초기값
// accumulator - 이전 연산결과와 스트림의 요소에 수행할 연산
// combiner - 병렬처리된 결과를 합치는데 사용할 연산(병렬 스트림)

// 예시1. int reduce(int identity, IntBinaryOperator op)
int count = intStream.reduce(0, (a,b) -> a + 1); // count(). a=0에서부터 1씩 더함
int sum = intStream.reduce(0, (a,b) -> a + b); // sum(). a=0에서부터 b씩 더함
        // 위 코드는 아래 3줄을 1줄로 줄여놓은 것과 같다.
        int a = identity;
        for(int b : stream)
            a = a + b;
int max = intStream.reduce(Integer.MIN_VALUE,(a,b)-> a > b ? a : b); // max(). a=최솟값에서부터 비교
int min = intStream.reduce(Integer.MAX_VALUE,(a,b)-> a < b ? a : b); // min(). a=최댓값에서부터 비교
 
// 예시2. OptionalInt reduce(IntBinaryOperator accumulator)
OptionalInt max = intStream.reduce((a,b) -> a > b ? a : b); // max()
OptionalInt min = intStream.reduce((a,b) -> a < b ? a : b); // min()
OptionalInt max = intStream.reduce(Integer::max); // static int max(int a, int b) 메서드 참조
OptionalInt min = intStream.reduce(Integer::min); // static int min(int a, int b) 메서드 참조

 

5. 스트림을 배열로 변환 – toArray( )

Object[] toArray() // 스트림의 모든 요소를 Object배열에 담아 반환
A[] toArray(IntFunction<A[]> generator) // 스트림의 모든 요소를 A타입의 배열에 담아 반환
 
Student[] stuNames = studentStream.toArray(Student[]::new); // OK. x-> new Student[x]

Student[] stuNames = studentStream.toArray(); // 에러
Object[] stuNames = studentStream.toArray(); // OK