24-3.최종 연산

24-3-1.요소 조사

스트림 연산은 값을 조작하여 최종 결과를 만들어 낸다. 중간에 여러 가지 연산이 끼어들 수 있지만 최종적으로는 뭔가 값을 산출해야 하며 최종 연산의 결과는 스트림이 아니라 합계나 검색 결과 등 특정 타입의 값이다. 가장 간단한 최종 연산은 스트림에 속한 요소의 개수를 구하는 count()이다.

long count()

리턴 타입이 int가 아니라 long으로 되어 있는데 거대한 스트림은 20억 개 이상의 요소를 가질 수 있다. 다음 예제는 컬렉션에 속한 나라의 개수를 구해 출력한다.

count
class JavaTest { public static void main(String[] args) { System.out.println(Data.nara.stream().count()); } }
실행결과	10

다음은 조건을 점검해 보고 만족하는 요소가 있는지 조사하여 진위형을 리턴한다.

boolean anyMatch(Predicate<T> predicate)

boolean allMatch(Predicate<T> predicate)

boolean noneMatch(Predicate<T> predicate)

모두 서술자를 인수로 취하여 점검할 조건을 지정한다. 메서드 이름이 의미하듯이 anyMatch는 하나라도 있는지, allMatch는 전부 만족하는지, noneMatch는 조건에 맞는게 하나도 없는지 점검한다.

allmatch
class JavaTest { public static void main(String[] args) { System.out.println(Data.nara.stream().anyMatch(c -> c.cont == Cont.AFRICA)); System.out.println(Data.nara.stream().allMatch(c -> c.popu > 10)); System.out.println(Data.nara.stream().noneMatch(c -> c.popu < 8)); } }
실행결과	true false true

여러 가지 조건으로 스트림의 요소를 조사해 보았다. 아프리카에 속한 나라는 있다고 조사된다. 모든 나라의 인구가 천만명이 넘는지 조사했는데 헝가리가 9백만명이라 거짓이다. 8백만 미만의 나라는 없는 것으로 조사된다.

이 메서드는 논리 연산자와 마찬가지로 쇼트 서키트 기능이 있다. anyMatch는 단 하나라도 조건을 만족하는 요소가 발견되면 더 이상 뒤쪽은 보지 않고 true를 리턴한다. 다른 메서드도 비슷한 방식이다. 다음 두 메서드는 스트림의 최대, 최소값을 조사한다.

Optional<T> max(Comparator<T> comparator)

Optional<T> min(Comparator<T> comparator)

요소 비교에 사용할 비교자를 인수로 전달한다. 비교자는 앞쪽 피연산자가 더 크면 양수, 뒤쪽 피연산자가 더 크면 음수, 두 값이 같으면 0을 리턴한다. 스트림이 비어 있을 수도 있어 T가 아닌 Optional<T>를 리턴하는데 이 타입에 대해서는 잠시 후 따로 연구해 보자.

minmax	실행결과
class JavaTest { public static void main(String[] args) { Optional<Integer> max = Data.nara.stream(). map(Country::getPopu). max((a, b) -> a-b); System.out.println(max.get()); Optional<Integer> min = Data.nara.stream(). map(Country::getPopu). min((a, b) -> a-b); System.out.println(min.get()); } }	1355 9

nara 스트림을 인구수의 정수 스트림으로 바꾼 후 max와 min으로 비교자를 전달하면 최대, 최소값을 찾아 준다. (a, b) -> a-b 람다 표현식 대신에 Integer::compare 메서드 레퍼런스를 전달해도 효과는 같다.

24-3-2.Optional

객체가 없는 상태를 보통 null로 표기한다. 지금까지 흔히 사용된 일반적인 방식이고 익숙하게 사용하고 있지만 간결성 면에서 불편한 면이 있다. 다음 예제를 보자.

nullable

실행결과

class Notebook { String model; Notebook(String model) { this.model = model; } } class Human { int age; String name; Notebook book; Human(int age, String name, String model) { book = new Notebook(model); this.age = age; this.name = name; } } class JavaTest { public static void main(String[] args) { Human kim = new Human(29, "김상형", "센스"); useBook(kim); } static void useBook(Human human) { System.out.println("내 노트북 : " + human.book.model); } }

내 노트북 : 센스

이 예제는 사람이 노트북을 소유한 상태를 표현한다. main에서 노트북을 가진 사람 객체를 생성한 후 노트북을 사용하는 useBook 메서드를 호출했다. 이 메서드는 노트북의 모델명을 출력하여 자랑만 한다.

useBook에서 노트북 모델명을 무작정 출력하는데 인수로 전달받은 human이 null일 수 있다. 또 사람마다 다 노트북을 가지는게 아니어서 노트북도 null이 될 수 있다. null값을 참조하면 실행중에 예외가 발생하므로 if문으로 조건을 점검하는 방어적 코드를 작성하는게 보통이다.

if (human != null) {

Notebook book = human.book;

if (book != null) {

System.out.println("내 노트북 : " + human.book.model);

}

}

둘 중 하나라도 null이면 아무 일도 일어나지 않는다. 물론 null일 경우의 처리를 별도의 else절로 지정할 수도 있다. 아주 상식적인 코드지만 들여쓰기가 깊고 비정상적인 상황에 대한 처리가 많아 핵심 코드가 잘 보이지 않는다. if문보다는 예외 처리 구문이 더 간단하지만 번거로운 것은 여전하다.

try {

System.out.println("내 노트북 : " + human.book.model);

}

catch (NullPointerException e) {

System.out.println(e.getMessage());

}

모든 객체 레퍼런스에 대해 null 방어 코드가 필요한 것은 아니다. Human.name이나 Notebook.model에 대해서는 이런 코드가 굳이 필요치 않다. 사람 이름이 없다는 것은 실행중에 발생할 수 있는 예외 상황이 아니라 디자인부터 뭔가 잘못된 것이다. 이런 상황은 있어서는 안되며 혹시라도 예외가 발생하면 실행중에 해결할 게 아니라 프로그램을 뜯어 고쳐야 한다.

반면 book 필드는 있을 수도 있고 없을 수도 있다. 모든 사람이 노트북을 소유하는 것은 아니므로 둘 다 정상적인 상황이다. 이런 상황을 표현하기 위해 자바 8에서 Optional<T> 클래스가 도입되었다. Optional<T>는 T 타입의 객체를 가진 상태와 아무것도 가지지 않은 상태를 표현하는 컨테이너이다. 객체를 감싸지만 없는 경우까지 포괄한다. 다음 세 개의 정적 메서드로 생성한다.

static <T> Optional<T> empty()

static <T> Optional<T> of(T value)

static <T> Optional<T> ofNullable(T value)

empty는 빈 상태로 생성하며 of는 객체를 저장한 상태로 초기화한다. ofNullable은 인수로 전달된 값을 저장하되 null이면 빈 상태로 초기화한다. 내부에 저장된 객체를 읽을 때는 다음 두 메서드를 사용한다.

boolean isPresent()

T get()

isPresent는 객체가 저장되어 있는지 조사한다. 이 메서드가 true를 리턴하면 내부에 객체가 있는 것이며 get 메서드로 객체를 안전하게 읽을 수 있다. 만약 빈 상태에서 get을 호출하면 예외가 발생한다. 예제를 다시 만들어 보자.

optional
import java.util.*; class Notebook { String model; Notebook(String model) { this.model = model; } } class Human { int age; String name; Optional<Notebook> book; Human(int age, String name, String model) { if (model == null || model.length() == 0) { book = Optional.empty(); } else { book = Optional.of(new Notebook(model)); } this.age = age; this.name = name; } } class JavaTest { public static void main(String[] args) { Human kim = new Human(29, "김상형", "레노보"); useBook(kim); Human lee = new Human(44, "이승우", null); useBook(lee); } static void useBook(Human human) { if (human.book.isPresent()) { String model = human.book.get().model; System.out.println("내 노트북 : " + model); } else { System.out.println("노트북이 없다."); } } }
실행결과	내 노트북 : 레노보 노트북이 없다.

Human 클래스의 book 필드는 Optional<Notebook> 타입으로 변경되었다. 즉, 노트북을 가질 수도 있고 아닐 수도 있다. 생성자는 노트북 이름이 있는가 아닌가에 따라 book을 비워 놓거나 아니면 노트북 객체를 생성하여 저장한다.

useBook 메서드는 isPresent 메서드로 노트북이 있는지 점검한 후 있으면 get 메서드로 노트북을 읽고 없으면 없다고 표시한다. 이 예제는 노트북을 가진 객체와 그렇지 않은 객체 모두에 대해 훌륭하게 잘 동작한다. 그러나 이렇게 조건을 점검할 바에야 if 문으로 null을 점검하는 것과 별반 다를게 없어 보인다. Optional은 단순한 체크보다 더 많은 기능을 제공한다. 다음 메서드는 비어 있지 않을 때의 동작을 람다식으로 지정한다.

void ifPresent(Consumer<T> consumer)

객체가 있으면 이 람다식을 실행하여 동작을 수행하며 비어 있으면 아무것도 하지 않는다. 이 메서드 자체가 if문을 대신한다.

ifpresent
.... class JavaTest { public static void main(String[] args) { Human kim = new Human(29, "김상형", "레노보"); useBook(kim); Human lee = new Human(44, "이승우", null); useBook(lee); } static void useBook(Human human) { human.book.ifPresent(b -> System.out.println("내 노트북 : " + b.model)); } }
실행결과	내 노트북 : 레노보

노트북 모델명을 출력하는 코드를 ifPresent 메서드안에 람다식으로 작성했다. 노트북을 가진 경우만 출력되며 그렇지 않으면 출력문을 무시한다. 다음 메서드는 조건 진위 여부에 따라 다른 조치를 취한다.

T orElse(T other)

T orElseGet(Supplier<T> other)

<X> T orElseThrow(Supplier<X> exceptionSupplier)

orElse 메서드는 비어 있을 경우 다른 대체적인 객체를 리턴한다. 비어 있지 않으면 물론 원래의 객체가 리턴된다. 다음 예제는 노트북이 없을 경우 싸구려 노트북을 만들어 준다.

orelse
.... class JavaTest { public static void main(String[] args) { Human kim = new Human(29, "김상형", "레노보"); useBook(kim); Human lee = new Human(44, "이승우", null); useBook(lee); } static void useBook(Human human) { Notebook book = human.book.orElse(new Notebook("싸구려")); System.out.println("내 노트북 : " + book.model); } }
실행결과	내 노트북 : 레노보 내 노트북 : 싸구려

orElse는 대체 객체를 인수열에서 미리 만들기 때문에 어쨌거나 객체를 만들어 놓고 본다. 함수를 호출하려면 인수를 먼저 생성해야 하니 어쩔 수 없다. 비어 있지 않으면 인수열에서 만든 객체는 사용되지 않고 버려져 비효율적이다.

이에 비해 orElseGet은 객체가 아니라 객체를 생성하는 람다식을 전달하여 불필요할 경우 아예 객체를 생성하지 않는다. orElse는 객체를 만들어 주고 선택 여부를 결정하지만 orElseGet은 객체를 만드는 방법을 가르쳐 주고 실행할 것인가를 결정한다. 다음과 같이 써도 동일하다.

Notebook book = human.book.orElseGet(() -> new Notebook("싸구려"));

orElseThrow 메서드는 객체가 비어 있을 때 예외를 던진다. get 메서드와 동작은 비슷하지만 예외의 종류를 인수로 지정할 수 있다는 점이 다르다.

Optional<T> filter(Predicate<T> predicate)

filter는 인수로 전달한 서술자로 객체를 점검하여 조건을 만족하면 객체를 가진 Optional 객체를 리턴하고 그렇지 않으면 빈 객체를 리턴한다. 객체가 처음부터 비어 있었다면 빈 객체가 리턴된다. 객체가 존재하는지와 조건을 만족하는지 보는 것이다.

optionfilter
class JavaTest { public static void main(String[] args) { Human kim = new Human(29, "김상형", "삼성 아티브"); useBook(kim); } static void useBook(Human human) { human.book.filter(b -> b.model.indexOf("삼성") != -1) .ifPresent(b -> System.out.println("삼성 노트북")); } }
실행결과	삼성 노트북

이름 문자열에 삼성이 포함되어 있으면 삼성 노트북이라고 출력한다. 객체가 null이거나 삼성이 아니면 아무 일도 일어나지 않는다.

<U> Optional<U> map(Function<T, U> mapper)

<U> Optional<U> flatMap(Function<T,Optional<U>> mapper)

map은 객체의 값으로부터 함수를 호출하여 다른 타입의 값을 추출하여 형태를 변경한다. 빈 객체이면 리턴되는 값도 빈 객체이다.

optionmap
class JavaTest { public static void main(String[] args) { Human kim = new Human(29, "김상형", ""); useBook(kim); } static void useBook(Human human) { String model = human.book.map(b -> b.model).orElse("이름없음"); System.out.println(model); } }
실행결과	이름없음

노트북으로부터 문자열 타입의 모델명을 추출하므로 리턴 타입은 Optional<String>이다. orElse 메서드로 이 문자열이 비어 있으면 "이름없음"이라는 모델명을 리턴하고 그렇지 않으면 이름 문자열을 구한다.

24-3-3.리덕션

리덕션은 스트림의 집합적인 값으로부터 하나의 최종값을 도출하는 연산이다. 합계나 평균 등이 좋은 예이며 컬렉션에서 뽑아낼 수 있는 가장 흔하고 유용한 정보이다.

T reduce(T identity, BinaryOperator<T> accumulator)

첫 번째 인수로 초기값을 주고 두 번째 인수로 누적자를 준다. 누적자는 초기값부터 시작해서 값을 계속 누적하여 다음 값을 만든다.

reduce
class JavaTest { public static void main(String[] args) { int total = Data.nara.stream() .map(Country::getPopu) .reduce(0, (i,j) -> i+j); System.out.println(total); } }
실행결과	2198

이 예제는 모든 국가의 총 인구수를 구한다. 정수 스트림으로 전환한 후 초기값 0에서 시작하여 다음 요소를 시작값에 계속 누적시킨다. 내부에서는 다음과 같은 루프를 돌 것이다.

int sum = 0;

for (int elem : stream) {

sum = sum + elem;

}

sum을 초기값 0에서 시작해서 스트림의 엘리먼트를 하나씩 누적시켜 합계를 구한다. 람다식으로 두 값을 더하는 동작을 지정했는데 이 동작은 자주 사용되므로 Integer 클래스에 int sum(int a, int b) 정적 메서드로 선언되어 있다. 람다식 대신 메서드 레퍼런스를 지정해도 효과는 같다.

reduce(0, Integer::sum);

모든 요소의 곱을 구하려면 다음과 같이 두 값을 곱하는 람다식을 지정한다. 누적곱이므로 초기값이 1이어야 한다는 점을 유의하자. 초기값이 0이면 어떤 값을 곱해도 결과는 0이 되어 버린다.

reduce(1, (i,j) -> i*j);

초기값이 굳이 필요치 않다면 다음 버전을 사용한다.

Optional<T> reduce(BinaryOperator<T> accumulator)

리턴값이 T가 아니라 Optional<T>라는 점이 다르다. 초기값이 없고 스트림이 완전히 비어 있을 때는 빈 객체가 리턴된다. 다음 코드도 동작은 같다.

reduce2
class JavaTest { public static void main(String[] args) { Optional<Integer> total = Data.nara.stream() .map(Country::getPopu) .reduce(Integer::sum); System.out.println(total.get()); } }
실행결과	2198

스트림이 비어 있지 않다는 것을 이미 알고 있으므로 get 메서드로 합계를 읽었다. 다음 예제는 인구의 최대, 최소값을 찾는다.

reduceminmax
class JavaTest { public static void main(String[] args) { Optional<Integer> min = Data.nara.stream() .map(Country::getPopu) .reduce(Integer::min); System.out.println(min.get()); Optional<Integer> max = Data.nara.stream() .map(Country::getPopu) .reduce(Integer::max); System.out.println(max.get()); } }
실행결과	9 1355

인구수만 추출한 뒤 Integer::min 함수로 리덕션을 수행하면 스트림을 순회하며 그 중에 가장 작은 값을 찾아 리턴한다. Integer::max 대신 람다식 (a,b) -> a > b ? a:b를 써도 같다. Optional을 쓰지 않으려면 초기값으로 충분히 큰 값 또는 충분히 작은 값을 주면 된다.

reduce(Integer.MAX_VALUE, Integer::min);

reduce(Integer.MIN_VALUE, Integer::max);

스트림이 비어 있지 않다는 것을 확실히 알고 있다면 그 중에 최소, 최대값이 반드시 존재하므로 굳이 초기값을 지정할 필요는 없다.

24-3-4.기본형 스트림

숫자형 필드의 합계를 구하는 코드를 다시 보면 map이 Stream<Integer>를 리턴한다는 면에서 낭비가 있다.

Optional<Integer> total = Data.nara.stream()

.map(Country::getPopu)

.reduce(Integer::sum);

원래 정수형인 popu 필드를 Integer로 박싱해서 스트림에 저장하며 reduce 메서드 내부에서 Integer의 정수값을 언박싱해서 읽으니 성능에 불리하다. 스트림이 클수록 이 문제가 심각해진다. 그래서 기본형에 대한 스트림이 별도로 제공된다.

IntStream mapToInt(ToIntFunction<? super T> mapper)

LongStream mapToLong(ToLongFunction<? super T> mapper)

DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)

IntStream은 정수형의 스트림이다. 기본형인 int 타입으로 스트림을 저장하며 언박싱할 필요가 없다. 리덕션을 하지 않고 바로 최종값을 구하는 메서드도 제공된다.

int sum()

OptionalInt max()

OptionalInt min()

OptionalDouble average()

sum 메서드만 호출하면 정수값의 합계를 바로 구할 수 있다. 스트림이 비어 있으면 0이 리턴된다. 최대, 최소, 평균도 바로 구할 수 있되 빈 스트림에 대해서는 Optional<Integer>의 기본형 버전이 대신 리턴된다. 스트림에 비해 Optional은 요소가 하나밖에 없어 기본형을 써도 성능 향상이 덜하다. 다음 예제는 기본형 스트림을 사용하여 인구 총합을 구한다.

maptoint
class JavaTest { public static void main(String[] args) { int total = Data.nara.stream() .mapToInt(Country::getPopu) .sum(); System.out.println(total); } }
실행결과	2198

mapToInt 메서드가 IntStream을 리턴하므로 박싱, 언박싱할 필요가 없다. 합계를 구할 때도 sum 메서드만 호출하면 된다. sum 메서드는 다음 코드와 같다.

reduce(0, Integer::sum)

다음 두 메서드는 일정한 범위의 정수 스트림을 생성한다.

static IntStream range(int startInclusive, int endExclusive)

static IntStream rangeClosed(int startInclusive, int endInclusive)

range 메서드는 끝값을 제외하며 rangeClosed는 끝값도 범위에 포함된다. 1~100의 합계는 다음과 같이 간단히 구할 수 있다.

rangeclosed
import java.util.stream.IntStream; class JavaTest { public static void main(String[] args) { int total = IntStream.rangeClosed(1, 100).sum(); System.out.println(total); } }
실행결과	5050

1 ~ 100의 정수 스트림을 만든 후 sum 메서드만 호출하면 된다. 만약 3의 배수로 구성된 스트림을 얻으려면 다음 필터를 중간에 넣어 준다.

.filter(i -> i % 3 == 0)

1 ~ 100의 정수중 3으로 나누어 떨어지는 수만 취한다. 기본형이 확실히 연산 속도는 빠르다. 다른 제네릭 버전의 메서드를 사용하려면 다음 메서드로 제네릭으로 복원한다.

Stream<Integer> boxed()

수치적인 연산만 할 때는 기본형 스트림으로 잠시 전환하는 것이 속도상 유리하다. 짧은 스트림은 별 상관없지만 대규모의 스트림일수록 박싱, 언박싱 비용이 비싸다.

24-3-5.collect

collect 메서드는 스트림으로부터 자료를 추출 및 가공하여 다른 형태로 변형하는 최종 연산이다. 함수의 원형은 간단하다.

<R,A> R collect(Collector<T,A,R> collector)

인수로 Collector 인터페이스 구현 객체 하나를 전달받아 이 객체 내의 메서드를 순서대로 호출하여 스트림을 가공한다. Collector에는 다음 추상 메서드가 선언되어 있다.

Supplier<A> supplier()

BiConsumer<A,T> accumulator()

Function<A,R> finisher()

BinaryOperator<A> combiner()

Set<Collector.Characteristics> characteristics()

각 메서드에 공급자, 누적자, 종료자, 결합자 등의 이름을 붙일 수 있고 각자 맡은 역할이 있다. 이 메서드들이 정확하게 무엇을 하고 어떤 임무를 띠는지는 레퍼런스에 잘 설명되어 있으며 모두 정확하게 구현해야 제대로된 Collector 객체의 역할을 수행한다.

대략적으로 설명하자면 새로운 결과를 저장하기 위한 컨테이너를 만들고 원본 스트림에서 요소를 읽어 일정한 규칙에 따라 새 컨테이너에 저장하며 최종 결과를 만들어 낸다. 병렬 처리할 때는 각 처리 결과를 병합해야 하며 내부 동작을 상세하게 정의하는 속성도 필요하다.

Collector 인터페이스의 타입 파라미터만 해도 3개나 되는데 원본 T에서 중간 변수 A를 거쳐 마지막 최종 결과인 R을 만들어낸다. 내부가 얼마나 복잡할지는 가히 짐작이 갈 것이다. Collector 인터페이스를 완벽히 분석해서 요건에 맞는 수집 객체를 만드는 것은 쉬운 일이 아니며 생산적이지도 않다. 자주 사용할만한 수집자 객체가 Collectors 클래스에 정의되어 있으니 우리는 이것만 잘 활용해도 충분하다.

<T> Collector<T,?,List<T>> toList()

<T> Collector<T,?,Set<T>> toSet()

toList는 T를 받아 List<T> 객체를 생성한다. toSet은 중복을 제거한 Set<T>객체를 생성한다. 더 정확하게 표현하자면 이런 동작을 하는 컬렉터 객체를 생성하여 스트림의 collect 메서드로 전달하면 해당 수집 처리를 수행한다. 다음 예제는 나라 스트림에서 이름만 쏙 빼서 문자열의 리스트로 수집한다.

collect
class JavaTest { public static void main(String[] args) { List<String> names = Data.nara.stream() .map(Country::getName) .collect(Collectors.toList()); for (String n : names) { System.out.print(n + " "); } } }
실행결과	한국 미국 중국 프랑스 나이지리아 독일 헝가리 베트남 칠레 캐나다

맵핑으로 나라 이름만 추출한 후 toList가 생성한 컬렉터로 넘기면 새로운 문자열 스트림을 생성하고 스트림을 순회하며 나라 이름을 하나씩 조사하여 스트림에 추가한다. 결과로 리턴된 List<String> 타입에는 나라 이름만 저장되어 있다. 다음 코드는 Country의 리스트를 생성한다.

List<Country> country = Data.nara.stream()

.collect(Collectors.toList());

for (Country c : country) {

System.out.println(c.name);

}

다음 메서드는 모든 요소를 문자열 하나로 조립하여 리턴한다.

static Collector<CharSequence,?,String> joining([CharSequence delimiter])

구분자를 주면 요소 중간 중간에 삽입된다. 보통 콤마로 구분하는 것이 무난하다.

collector
class JavaTest { public static void main(String[] args) { String names = Data.nara.stream() .map(Country::getName) .collect(Collectors.joining(", ")); System.out.println(names); } }
실행결과	한국, 미국, 중국, 프랑스, 나이지리아, 독일, 헝가리, 베트남, 칠레, 캐나다

내부적으로 StringBuilder를 사용하여 여러 개의 요소를 결합하더라도 성능 감소는 없다. 다음 예제는 스트림의 개수, 최대, 최소값을 찾는다.

collectminmax
class JavaTest { public static void main(String[] args) { long num = Data.nara.stream() .collect(Collectors.counting()); System.out.println(num); Optional<Integer> max = Data.nara.stream() .map(Country::getPopu) .collect(Collectors.maxBy(Integer::compare)); System.out.println(max.get()); Optional<Integer> min = Data.nara.stream() .map(Country::getPopu) .collect(Collectors.minBy(Integer::compare)); System.out.println(min.get()); } }
실행결과	10 1355 9

다음 예제는 인구수의 합계와 평균을 구한다.

collectaverage
class JavaTest { public static void main(String[] args) { int sum = Data.nara.stream() .collect(Collectors.summingInt(Country::getPopu)); System.out.println(sum); double avg = Data.nara.stream() .collect(Collectors.averagingInt(Country::getPopu)); System.out.println(avg); } }
실행결과	2198 219.8

long과 double 타입에 대해서도 summingLong, summingDouble, averagingLong, averagingDouble 메서드가 제공된다. 다음 예제는 합계, 평균, 최대, 최소값을 한방에 구한다.

summing
class JavaTest { public static void main(String[] args) { IntSummaryStatistics summary = Data.nara.stream() .collect(Collectors.summarizingInt(Country::getPopu)); System.out.println(summary); } }
실행결과	IntSummaryStatistics{count=10, sum=2198, min=9, average=219.800000, max=1355}

다음은 리덕션 연산을 수행하는 메서드이다.

static <T> Collector<T,?,T> reducing(T identity, BinaryOperator<T> op)

static <T> Collector<T,?,Optional<T>> reducing(BinaryOperator<T> op)

static <T,U> Collector<T,?,U> reducing(U identity, Function< T, U> mapper, BinaryOperator<U> op)

간단하게 합계만 구해 보자. 정수형으로 맵핑하지 않고도 정수값을 추출하여 합계를 바로 구할 수 있다.

reducesum
class JavaTest { public static void main(String[] args) { int sum = Data.nara.stream() .collect(Collectors.reducing(0, Country::getPopu, Integer::sum)); System.out.println(sum); } }
실행결과	2198

스트림의 reduce 연산과 사실상 비슷하게 사용한다. 그러나 병렬적으로 동작할 수 있고 스트림의 내용을 변경한다는 면이 다르다. 간단한 리덕션에는 reduce 메서드를 쓰는 것이 편리하고 복잡한 리덕션에는 collect를 쓴다. 다음은 그룹핑 컬렉터이다. 일정한 기준에 따라 요소를 나누어 맵을 작성한다.

static <T,K> Collector<T,?,Map<K,List<T>>> groupingBy(Function< T, K> classifier)

인수로는 그룹핑에 사용할 키를 리턴하는 함수를 전달한다. 가장 간단한 버전만 예제를 만들어 보자.

grouping
class JavaTest { public static void main(String[] args) { Map<Cont, List<Country>> map = Data.nara.stream() .collect(Collectors.groupingBy(Country::getCont)); Set<Cont> keys = map.keySet(); Iterator<Cont> key = keys.iterator(); while (key.hasNext()) { Cont cont = key.next(); System.out.print(cont + " : "); List<Country> n = map.get(cont); for (Country c : n) { System.out.print(c.name + " "); } System.out.println(); } } }
실행결과	AFRICA : 나이지리아 EUROPE : 프랑스 독일 헝가리 AMERICA : 미국 칠레 캐나다 ASIA : 한국 중국 베트남

그룹핑할 키만 주면 키와 리스트의 맵을 리턴한다. 예제에서는 대륙으로 나라를 그룹핑했다. 그룹핑은 딱 한 줄로 완료되지만 이 결과를 출력하는 코드가 더 길다. 분할은 그룹핑의 특수한 예로 진위형에 따라 그룹을 나누는 것이다.

static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningBy(Predicate<T> predicate)

서술자를 인수로 취해 이 값의 진위 여부에 따라 스트림의 요소를 분할한다. 다음 예제는 OECD 국가 여부에 따라 두 개의 그룹을 분할한다.

oecdgroup
class JavaTest { public static void main(String[] args) { Map<Boolean, List<Country>> map = Data.nara.stream() .collect(Collectors.groupingBy(Country::isOecd)); Set<Boolean> keys = map.keySet(); Iterator<Boolean> key = keys.iterator(); while (key.hasNext()) { Boolean oecd = key.next(); System.out.print(oecd + " : "); List<Country> n = map.get(oecd); for (Country c : n) { System.out.print(c.name + " "); } System.out.println(); } } }
실행결과	false : 중국 나이지리아 베트남 true : 한국 미국 프랑스 독일 헝가리 칠레 캐나다

이상으로 스트림을 연구해 보았다. 여기까지의 예제를 구경해 보면 SQL 구문과 많이 흡사하다는 것을 알 수 있다. 짧고 잘 동작하지만 난이도는 높은 편이어서 예제 코드만 보고 실전에 바로 사용하기는 솔직히 만만치 않다. 2차 그룹핑까지 수행할 수 있는 메서드의 원형을 보자. 이 메서드는 그룹핑에 사용할 키와 2차 그룹핑에 사용할 컬렉터를 인수로 요구한다.

static <T,K,D,A,M extends Map<K,D>> Collector<T,?,M> groupingBy(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)

원형만 봐도 엄청나게 복잡하며 진짜 토나올 지경이다. 내부적으로 생성하는 Collector 객체의 동작을 완전히 꿰고 있어야만 제대로 쓸 수 있다. 배워 두면 유용하게 쓰이겠지만 지금 당장 공부하고 싶다는 생각은 들지 않을 것이다. 솔직히 저 메서드를 제대로 이해해서 쓰는 것보다 컬렉션 연산으로 맨땅에 헤딩하는게 더 속편할지도 모른다.

스트림이 모든 면에서 장점이 많지만 난이도가 너무 높고 익숙하게 제대로 쓰는데는 굉장히 많은 연습이 필요하다. 한 번에 스트림의 모든 것을 다 이해하기는 어려우니 당장은 기본적인 것만 쓰고 고급 기법은 필요할 때 점진적으로 연구해서 익숙해지는 작전이 바람직하다.