🐹 chap6. 스트림 으로 데이터 수집

• 통화별로 트랜잭션을 그룹화한 코드(명령형 버전)

// 그룹화한 트랜잭션을 저장할 맵 생성
Map<Currency, List<Transaction>> transactionsByCurrencies = new HashMap<>();

for (Transaction transaction: transactions) {
    Currency currency = transaction.getCurrency(); // 트랜잭션의 통화를 추출
    List<Transaction> transactionsForCurrency =
        transactionsByCurrencies.get(currency);
    if (transactionsForCurrency == null) {
        // 현재 통화를 그룹화하는 맵에 항목이 없으면 항목을 만든다.
        transactionsForCurrency = new ArrayList<>();
        transactionsByCurrencies.put(currency, transactionsForCurrency);
    }
    // 같은 통화를 가진 트랜잭션 리스트에 현재 탐색 중인 트랜잭션을 추가한다. 
    transactionsForCurrency.add(transaction);
}

‘통화별로 트랜잭션 리스트를 그룹화하시오’라고 간단히 표현할 수 있지만 코드가 무엇을 실행하는지 한 눈에 파악하기 어렵다. Stream에 toList를 사용하는 대신 더 범용적인 컬렉터 파라미터를 collect 메서드에 전달함으로써 원하는 연산을 간결하게 구현할 수 있다.

• 통화별로 트랜잭션을 그룹화한 코드(함수형 버전)

Map<Currency, List<Transaction>> transactionsByCurrencies =
    transactions.stream().collect(groupingBy(Transaction::getCurrency));

6.1 컬렉터란 무엇인가?

위 예제는 명령형 프로그래밍에 비해 함수형 프로그래밍이 얼마나 편리한지 명확하게 보여준다.

함수형 프로그래밍에서는 ‘무엇’을 원하는지 직접 명시할 수 있어서 어떤 방법으로 이를 얻을지는 신경 쓸 필요가 없다. 여기서는 groupingBy를 이용해서 ‘각 키(통화) 버킷 그리고 각 키 버킷에 대응하는 요소 리스트를 값으로 포함하는 맵(Map)을 만들라’는 동작을 수행한다.

명령형 코드에서는 다중 루프와 조건문을 추가하며 가독성과 유지보수성이 크게 떨어진다.

6.1.1 고급 리듀싱 기능을 하는 컬렉터

함수형 API의 장점 → 높은 수준의 조합성과 재사용성

컬렉터의 최대 강점은 collect로 결과를 수집하는 과정을 간단하면서도 유연한 방식으로 정의할 수 있다는 점이다.

• 스트림에 collect를 호출하면 스트림의 요소에 내부적으로 리듀싱 연산이 수행됨
• 명령형 프로그래밍에서는 우리가 직접 구현해야 했던 작업이 자동으로 수행됨
• collect에서는 리듀싱 연산을 이용해서 스트림의 각 요소를 방문하면서 컬렉터가 작업을 처리한다.

Collectors 유틸리티 클래스는 자주 사용하는 컬렉터 인스턴스를 손쉽게 생성할 수 있는 정적 팩토리 메서드를 제공한다. 예를 들어 가장 많이 사용하는 직관적인 메서드로 toList를 꼽을 수 있다. toList는 스트림의 모든 요소를 리스트로 수집한다.

List<Transaction> transactions =
    transactionStream.collect(Collectors.toList());

6.1.2 미리 정의된 컬렉터

groupingBy 같이 Collectors 클래스에서 제공하는 팩토리 메서드의 기능을 설명한다.

• Collectors에서 제공하는 메서드의 기능

  • 스트림 요소를 하나의 값으로 리듀스하고 요약

    : 이전 예제처럼 트랜잭션 리스트에서 트랜잭션 총합을 찾는 등의 다양한 계산을 수행할 때 유용

  • 요소 그룹화

    : 이전 예제를 다수준으로 그룹화하거나 각각의 결과 서브그룹에 추가로 리듀싱 연산을 적용할 수 있음 (다양한 컬렉터 조합을 통해)

  • 요소 분할

    : 한 개의 인수를 받아 boolean을 반환하는 함수, 즉 프레디케이트를 그룹화 함수로 사용

6.2 리듀싱과 요약

counting()

counting() 이라는 팩토리 메서드가 반환하는 컬렉터로 메뉴에서 요리 수를 계산

long howManyDishes = menu.stream().collect(Collectors.counting());

다음처럼 불필요한 과정을 생략할 수 있다.

long howManyDishes = menu.stream().count();

counting 컬렉터는 다른 컬렉터와 함께 사용할 때 위력을 발휘한다.

Collectors 클래스의 정적 팩토리 메서드를 모두 임포트

import static java.util.stream.Collectors.*;

Collectors.counting()을 간단하게 counting()으로 표현할 수 있다.

6.2.1 스트림값에서 최댓값과 최솟값 검색

메뉴에서 가장 칼로리가 높은 요리를 찾는다고 가정하자.

Collectors.maxBy, Collectors.minBy 두 개의 메서드를 이용해서 스트림의 최댓값과 최솟값을 계산할 수 있다. 두 컬렉터는 스트림의 요소를 비교하는 데 사용할 Comparator를 인수로 받는다.

Comparator<Dish> dishCaloriesComparator = 
    Comparator.comparingInt(Dish::getCalories);

Optional<Dish> mostCalorieDish =
    menu.stream()
        .collect(maxBy(dishCaloriesComparator));

Opitonal는 값을 포함하거나 또는 포함하지 않을 수 있는 컨테이너이다.(자바 8이후)

또한 스트림에 있는 객체의 숫자 필드의 합계나 평균 등을 반환하는 연산에도 리듀싱 기능이 자주 사용된다. 이러한 연산을 요약(summarization) 연산이라 부른다.

6.2.2 요약 연산

summingInt(), summarizingInt()

Collectors 클래스는 Collectors.summingInt라는 특별한 요약 팩토리 메서드를 제공한다.

• 객체를 int로 매핑하는 함수를 인수로 받는다.
• summingInt의 인수로 전달된 함수는 객체를 int로 매핑한 컬렉터를 반환한다.
• summingInt가 collect 메서드로 전달되면 요약 작업을 수행한다.

int totalCalories = menu.stream().collect(summingInt(Dish::getCalories));

칼로리로 매핑된 각 요리의 값을 탐색하면서 초깃값(여기서는 0)으로 설정되어 있는 누적자에 칼로리를 더한다.

Collectors.summingLong과 Collectors.summingDouble 메서드는 같은 방식으로 동작하며 각각 long 또는 double 형식의 데이터로 요약한다는 점만 다르다.

이외의 평균값 계산 등의 연산도 요약 기능으로 제공된다. 즉, Collectors.averagingInt, averagingLong, averagingDouble 등으로 다양한 형식으로 이루어진 숫자 집합의 평균을 계산할 수 있다.

double avgCalories =
    menu.stream.collect(averagingDouble(Dish::getCalories));

컬렉터로 종종 두 개 이상의 연산을 한 번에 수행해야 할 때도 있다. 이런 상황에서는 팩토리 메서드 summarizingInt가 반환하는 컬렉터를 사용할 수 있다. 예를 들어 다음은 하나의 요약 연산으로 메뉴에 있는 요리 수, 요리의 칼로리 합계, 평균, 최댓값, 최솟값 등을 계산하는 코드다.

IntSummaryStatistics menuStatistics = 
    menu.stream().collect(summarizingInt(Dish::getCalories));

위 코드를 실행하면 IntSummaryStatistics 클래스로 모든 정보가 수집된다. menuStatistics 객체를 출력하면 다음과 같은 정보를 확인할 수 있다.

IntSummaryStatistics{count=9, sum=4300, min=120, average=477.777778, max=800}

마찬가지로 int뿐만 아니라 long이나 double에 대응하는 summarizingLong, summarizingDouble 메서드와 관련된 LongSummaryStatistics, DoubleSummaryStatistics 클래스도 있다.

6.2.3 문자열 연결

joinning()

컬렉터에 joining 팩토리 메서드를 이용하면 스트림의 각 객체에 toString 메서드를 호출해서 추출한 문자열을 하나의 문자열로 연결해서 반환한다.

String shortMenu = menu.stream.map(Dish::getName).collect(joinning());

joinning 메서드는 내부적으로 StringBuilder를 이용해서 문자열을 하나로 만든다. Dish 클래스가 요리명을 반환하는 toString 메서드를 포함하고 있다면 다음 코드처럼 map으로 각 요리의 이름을 추출하는 과정을 생략할 수 있다.

String shortMenu = menu.stream().collect(joinning());

결과는 다음과 같다.

porkbeefchickenfrench friesriceseason fruitpizzaprawnssalmon

하지만 결과 문자열을 해석할 수가 없다. 두 요소 사이에 구분 문자열을 넣을 수 있도록 오버로드된 joinning 팩토리 메서드를 사용한다.

String shortMenu = menu.stream().map(Dish::getName).collect(joinning(", "));

다음은 위 코드를 실행한 결과이다.

pork, beef, chicken, french fries, rice, season fruit, pizza, prawns, salmon

지금까지 스트림을 하나의 값으로 리듀스 하는 다양한 컬렉터를 확인해보았다.

6.2.4 범용 리듀싱 요약 연산

지금까지 살펴본 모든 컬렉터는 reducing 팩토리 메서드로도 정의할 수 있다. 즉, 범용 Collectors.reducing으로도 구현할 수 있다. 예를 들어 다음 코드처럼 reducing 메서드로 만들어진 컬렉터로도 메뉴의 모든 칼로리 합계를 계산할 수 있다.

int totalCalories = 
    menu.stream().collect(reducing(0, Dish::getCalories, (i, j) -> i + j));

reducing은 인수 세 개를 받는다.

• 첫 번째 인수 : 리듀싱 연산의 시작값이거나 스트림에 인수가 없을 때는 반환값 (숫자 합계에서는 인수가 없을 때 반환값으로 0이 적합하다.)
• 두 번째 인수 : 요리를 칼로리 정수로 변환할 때 사용한 변환 함수
• 세 번째 인수 : 같은 종류의 두 항목을 하나의 값으로 더하는 BinaryOperator (예제에서는 두 개의 int가 사용되었다.)

다음처럼 한 개의 인수를 가진 reducing 버전을 이용해서 가장 칼로리가 높은 요리를 찾는 방법도 있다.

Optional<Dish> mostCalorieDish =
    menu.stream().collect(reducing(
        (d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2));

한 개의 인수를 갖는 reducing 팩토리 메서드는 세 개의 인수를 갖는 reducing 메서드에서 스트림의 첫 번째 요소를 시작 요소, 즉 첫 번째 인수로 받으며, 자신을 그대로 반환하는 항등 함수를 두 번째 인수로 받는 상황에 해당한다. 즉, 한 개의 인수를 갖는 reducing 컬렉터는 시작값이 없으므로 빈 스트림이 넘겨졌을 때 시작값이 설정되지 않는 상황이 벌어진다. 그래서 **한 개의 인수를 갖는 reducing은 Optional 객체를 반환**한다.

collect와 reduce

Stream 인터페이스의 collect와 reduce의 차이점은 무엇일까? 둘은 같은 기능을 구현할 수 있다.

다음 코드에서 보여주는 것처럼 toList 컬렉터를 사용하는 collect 대신 reduce 메서드를 사용할 수 있다.

Stream<Integer> stream = Arrays.asList(1, 2, 3, 4, 5, 6).stream();
List<Integer> numbers 
    = stream.reduce(
        new ArrayList<Integer>(), 
        (List<Integer> l, Integer e) -> {l.add(e); return l;},
        (List<Integer> l1, List<Integer> l2) -> {l1.addAll(l2); return l1;});

위 코드에는 의미론적인 문제와 실용성 문제 등 두 가지 문제가 발생한다.

• 의미론적 문제

  collect 메서드는 도출하려는 결과를 누적하는 컨테이너를 바꾸도록 설계된 메서드인 반면 reduce는 두 값을 하나로 도출하는 불변형 연산이라는 점

  예제에서 reduce 메서드는 누적자로 사용된 리스트를 변환시키므로 reduce를 잘못 활용한 예에 해당한다.

• 실용성 문제

  여러 스레드가 동시에 같은 데이터 구조체를 고치면 리스트 자체가 망가져버리므로 리듀싱 연산을 병렬로 수행할 수 없다는 점

  이 문제를 해결하기 위해서는 매번 새로운 리스트를 할당해야 한다. → 객체 할당 때문에 성능 저하

  가변 컨테이너 관련 작업이면서 병렬성을 확보하려면 collect 메서드로 리듀싱 연산을 구현하는 것이 바람직하다

컬렉션 프레임워크 유연성 : 같은 연산도 다양한 방식으로 수행할 수 있다.

reducing 컬렉터를 사용한 이전 예제에서 람다 표현식 대신 Integer 클래스의 sum 메서드 참조를 이용하면 코드를 좀 더 단순화 할 수 있다.

int totalCalories = 
    menu.stream().collect(reducing(0, Dish::getCalories, (i, j) -> i + j));

// sum 메서드 참조
int totalCalories = 
    menu.stream().collect(reducing(0, // 초깃값
                            Dish::getCalories, // 변환 함수
                            Integer::sum));    // 합계 함수

리듀싱 연산과정은 누적자를 초깃값으로 초기화하고, 합계 함수를 이용해서 각 요소에 변환 함수를 적용한 결과 숫자를 반복적으로 조합한다.

counting 컬렉터도 세 개의 인수를 갖는 reducing 팩토리 메서드를 이용해서 구현할 수 있다.

다음 코드처럼 스트림의 Long 객체 형식의 요소를 1로 변환한 다음에 모두 더할 수 있다.

public static <T> Collector<T, ?, Long> counting() {
    return reducing(0L, e -> 1L, Long::sum);
}

제네릭 와일드카드 ‘?’ 사용법

위 예제에서 counting 팩토리 메서드가 반환하는 컬렉터 시그니처의 두 번째 제네릭 형식으로 와일드카드 ?이 사용되었다. ?는 컬렉터의 누적자 형식이 알려지지 않았음(누적자의 형식이 자유로움)을 의미한다.

int totalCalories =
    menu.stream().map(Dish::getCalories).reduce(Integer::sum).get

컬렉터를 이용하지 않고 같은 연산을 수행한 것이다.

한 개의 인수를 갖는 reduce를 스트림에 적용한 다른 예제와 마찬가지로 reduce(Integer::sum)도 빈 스트림과 관련한 널 문제를 피할 수 있도록 int가 아닌 Optional<Integer>를 반환한다. 그리고 get으로 Optional 객체의 값을 추출했다. (요리 스트림이 비어있지 않다는 사실을 알고 있으므로)

일반적으로는 기본값을 제공할 수 있는 orElse, orElseGet 등을 이용해서 Optional의 값을 얻어오는 것이 좋다. 마지막으로 스트릠을 IntStream으로 매핑한 다음에 sum 메서드를 호출하는 방법으로도 결과를 얻을 수 있다.

int totalCalories = menu.stream().mapToInt(Dish::getCalories).sum();

자신의 상황에 맞는 최적의 해법 선택

지금까지 함수형 프로그래밍에서는 하나의 연산을 다양한 방법으로 해결할 수 있음을 보여준다. 또한 스트림 인터페이스에서 직접 제공하는 메서드를 이용하는 것에 비해 컬렉터를 이용하는 코드가 더 복잡하다는 사실도 보여준다. 코드가 좀 더 복잡한 대신 재사용성과 커스터마이즈 가능성을 제공하는 높은 수준의 추상화와 일반화를 얻을 수 있다.

가독성과 성능 두 마리 토끼를 잡기 위해서는 다양한 해결 방법을 확인한 후 가장 일반적으로 문제에 특화된 해결책을 고르는 것이 바람직하다.

예를 들어 메뉴 전체의 칼로리를 계산하는 예제에서는 (IntStream을 사용한)가장 마지막에 확인한 해결 방법이 가장 가독성이 좋고 간결하다. 또한 IntStream 덕분에 자동 언박싱 연산을 수행하거나 Integer를 int로 변환하는 과정을 피할 수 있으므로 성능까지 좋다.

• Quiz. 리듀싱으로 문자열 연결하기

  아래 joining 컬렉터를 6.2.3절에서 사용한 reducing 컬렉터로 올바르게 바꾼 코드를 모두 선택하시오.

    String shortMenu = menu.stream().map(Dish::getName).collect(joining());
      
    1. String shortMenu = menu.stream().map(Dish::getName)
            .collect(reducing((s1, s2) -> s1 + s2)).get();
    2. String shortMenu = menu.stream()
            .collect(reducing((d1, d2) -> d1.getName() + d2.getName())).get();
    3. String shortMenu = menu.stream()
            .collect(reducing("", Dish::getName, (s1, s2) -> s1 + s2));
  

  • 정답

    1번과 3번이 정답이며, 2번은 컴파일되지 않는 코드다.

    1. 원래의 joining 컬렉터처럼 각 요리를 요리명으로 변환한 다음에 문자열을 누적자로 사용해서 문자열 스트림을 리듀스하면서 요리명을 하나씩 연결한다.
    2. reducing은 BinaryOperator, 즉 BiFunction<T, T, T>를 인수로 받는다. 즉, reducing은 두 인수를 받아 **같은 형식을 반환**하는 함수를 인수로 받는다. 하지만 2번 람다 표현식은 두 개의 요리를 인수로 받아 문자열을 반환한다.
    3. 빈 문자열을 포함하는 누적자를 이용해서 리듀싱 과정을 시작하며, 스트림의 요리를 방문하면서 각 요리를 요리명으로 변환한 다음에 누적자로 추가한다. 세 개의 인수를 갖는 reducing은 누적자 초깃값을 설정할 수 있으므로 Optional을 반환할 필요가 없다.

    1번과 3번이 올바른 코드이긴 하지만 단지 범용 reducing으로 joining을 구현할 수 있음을 보여주는 예제일 뿐이다. 실무에서는 joining을 사용하는 것이 가독성과 성능에 좋다.

6.3 그룹화

데이터 집합을 하나 이상의 특성으로 분류해서 그룹화하는 연산

자바 8의 함수형을 이용하면 가독성 있는 한 줄의 코드로 그룹화를 구현할 수 있다.

메뉴 그룹화 예제(고기를 포함하는 그룹, 생선을 포함하는 그룹, 나머지 그룹)

다음처럼 팩토리 메서드 Collectors.groupingBy를 이용해서 쉽게 메뉴를 그룹화할 수 있다.

Map<Dish.Type, List<Dish>> dishesByType =
    menu.stream().collect(groupingBy(Dish::getType));

다음은 Map에 포함된 결과다.

{FISH=[prawns, salmon], OTHER=[french fries, rice, season fruit, pizza],
 MEAT=[pork, beef, chicken]}

스트림의 각 요리에서 Dish.Type과 일치하는 모든 요리를 추출하는 함수를 groupingBy 메서드로 전달했다. 이 함수를 기준으로 스트림이 그룹화되므로 이를 분류 함수라고 부른다.

예제) 400칼로리 이하를 ‘diet’로, 400~700 칼로리를 ‘normal’로, 700 칼로리 초과를 ‘fat’ 요리로 분류

Dish 클래스에는 이러한 연산에 필요한 메서드가 없으므로 메서드 참조 대신 람다 표현식으로 필요한 로직을 구현할 수 있다.

public enum CaloricLevel { DIET, NORMAL, FAT }

Map<CaloricLevel, List<Dish>> dishesByCaloricLevel = menu.stream().collect(
    groupingBy(dish -> {
        if (dish.getCalories() <= 400) return CaloricLevel.DIET;
        else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
        else return CaloricLevel.FAT;
    }));

이번에는 요리 종류와 칼로리 두 가지 기준으로 동시에 그룹화할 수 있는가를 확인해보자.

6.3.1 그룹화된 요소 조작

요소를 그룹화 한 다음에는 각 결과 그룹의 요소를 조작하는 연산이 필요하다.

ex) 500 칼로리가 넘는 요리만 필터링한다고 가정하자. 다음 코드처럼 그룹화 하기 전에 프레디케이트로 필터를 적용해 문제를 해결할 수 있다 생각할 것이다.

Map<Dish.Type, List<Dish>> caloricDishesByType =
        menu.stream().filter(dish -> dish.getCalories() > 500)
                     .collect(groupingBy(Dish::getType));

위 코드로 문제를 해결할 수 있지만 단점도 존재한다. 메뉴 요리는 다음처럼 맵 형태로 되어 있으므로 코드에 위 기능을 사용하려면 맵에 코드를 적용해야 한다.

{OTHER=[french fries, pizza], MEAT=[pork, beef]}

→ 필터 프레디케이트를 만족하는 FISH 종류 요리는 없으므로 결과 맵에서 해당 키 자체가 사라진다!

Collectors 클래스의 groupingBy 팩토리 메서드의 두 번째 인수를 가지고 이를 해결할 수 있다. 두 번째 Collector 안으로 필터 프레디케이트를 이동시킨다.

Map<Dish.Type, List<Dish>> caloricDishesByType =
    menu.stream()
        .collect(groupingBy(Dish::getType,
                            filtering(dish -> dish.getCalories() > 500, toList())));

이렇게 되면 목록이 비어있는 FISH도 항목으로 추가된다.

{OTHER=[french fries, pizza], MEAT=[pork, beef], FISH=[]}

ex) 그룹의 각 요리를 관련 이름 목록으로 변환

매핑 함수를 이용해 요소를 변환해준다. filtering 컬렉터처럼 mapping 메서드를 groupingBy의 인수로 사용할 수 있다.

Map<Dish.Type, **List<String>**> dishNamesByType =
    menu.stream()
        .collect(groupingBy(Dish::getType, mapping(Dish::getName, toList())));

이전 예제와 달리 결과 맵의 각 그룹은 요리가 아니라 문자열 리스트이다.

groupingBy와 연계해 세 번째 컬렉터를 사용해서 일반 맵이 아닌 flatMap 변환을 수행할 수 있다.

Map<String, List<String>> dishTags = new HashMap<>();
dishTags.put("pork", asList("greasy", "salty"));
dishTags.put("beef", asList("salty", "roasted"));
dishTags.put("chicken", asList("fried", "crisp"));
dishTags.put("french fries", asList("greasy", "fries"));
dishTags.put("rice", asList("light", "natural"));
dishTags.put("season fruit", asList("fresh", "natural"));
dishTags.put("pizza", asList("tasty", "salty"));
dishTags.put("prawns", asList("tasty", "roasted"));
dishTags.put("salmon", asList("delicious", "fresh"));

위 태그 목록을 가진 각 요리로 구성된 맵에서 flatMapping 컬렉터를 이용하면 각 형식의 요리의 태그를 간편하게 추출할 수 있다.

Map<Dish.Type, Set<String>> dishNamesByType = 
    menu.stream()
        .collect(grouping(Dish::getType,
                        flatMapping(dish -> dishTags.get(dish.getName()).stream(), toSet())));

각 요리에서 태그 리스트를 얻어야 한다. 두 수준의 리스트를 평면화하려면 flatMap을 수행해야 한다.

{MEAT=[salty, greasy, roasted, fried, crisp], FISH=[roasted, tasty, fresh, delicious],
 OTHER=[salty, greasy, natural, light, tasty, fresh, fried]}

6.3.2 다수준 그룹화

두 인수를 받는 팩토리 메서드 Collectors.groupingBy를 이용해서 항목을 다수준으로 그룹화할 수 있다.

groupingBy를 중첩하여 바깥쪽 groupingBy 메서드에 스트림의 항목을 분류할 두 번째 기준을 정의하는 내부 groupingBy를 전달하여 두 수준으로 스트림의 항목을 그룹화할 수 있다.

Map<Dish.Type, Map<CaloricLevel, List<Dish>>> dishesByTypeCaloricLevel =
menu.stream().collect(
    groupingBy(Dish::getType,  // 첫 번째 수준의 분류 함수
        grouping(dish -> {     // 두 번째 수준의 분류 함수
            if (dish.getCalories() <= 400) return CaloricLevel.DIET;
            else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
            else return CaloricLevel.FAT;
        })
    )
);

그룹화의 결과로 다음과 같은 두 수준의 맵이 만들어진다.

{MEAT={DIET=[chicken], NORMAL=[beef], FAT=[pork]}, 
 FISH={DIET=[prawns], NORMAL=[salmon]},
 OTHER={DIET=[rice, seasonal fruit], NORMAL=[french fries, pizza]}}

• 첫 번째 수준의 분류 함수

  분류 키 값 : fish, meat, other

• 두 번째 수준의 분류 함수

  분류 키 값 : normal, diet, fat

• 최종

  • 첫 번째 키와 두 번째 키의 기준에 부합하는 요소 리스트 값 : salmon, pizza 등

다수준 그룹화 연산은 다양한 수준으로 확장 가능하다. n수준 그룹화의 결과는 n수준 트리 구조로 표현되는 n수준 맵이 된다.

6.3.3 서브그룹으로 데이터 수집

groupingBy 컬렉터에 두 번째 인수로 counting 컬렉터를 전달해서 메뉴에서 요리의 수를 종류별로 계산할 수 있다.

Map<Dish.Type, Long> typesCount = 
    menu.stream().collect(groupingBy(Dish::getType, counring()));

다음은 결과 맵이다.

{MEAT=3, FISH=2, OTHER=4}

분류 함수 한 개의 인수를 갖는 grouping(f)는 사실 groupingBy(f, toList())의 축약형이다.

요리의 종류를 분류하는 컬렉터로 메뉴에서 가장 높은 칼로리를 가진 요리를 찾는 프로그램도 다시 구현할 수 있다.

Map<Dish.Type, Optional<Dish>> mostCaloricByType =
    menu.stream()
        .collect(groupingBy(Dish::getType,
                            maxBy(comparingInt(Dish::getCalories))));

→ 요리의 종류(key), Oprional(value)를 값으로 갖는 맵 반환

{FISH=Optional[salmon], OTHER=Oprional[pizza], MEAT=Optional[pork]}

컬렉터 결과를 다른 형식에 적용하기

이전 그룹화 연사에서 맵의 모든 값을 Optional로 감쌀 필요가 없으므로 Optional을 삭제할 수 있다.

Collectors.collectingAndThen으로 컬렉터가 반환한 결과를 다른 형식으로 활용할 수 있다.

Map<Dish.Type, Dish> mostCaloricByType =
    menu.stream()
        .collect(groupingBy(Dish::getType,  // 분류 함수
                            collectingAndThen(
                                maxBy(comparingInt(Dish::getCalories)),  // 감싸인 컬렉터
                            Optional::get)));           // 변환 함수

Optional::get으로 반환된 Optional에 포함된 값을 추출한다. 리듀싱 컬렉터는 절대 Optional.empty()를 반환하지 않으므로 안전한 코드다. 다음은 맵의 결과다.

{FISH=salmon, OTHER=pizza, MEAT=pork}

• 중첩 컬렉터의 동작(가장 외부 계층에서 안쪽으로 작업 수행)
  • 컬렉터는 점선으로 표시되어 있으며 groupingBy는 가장 바깥쪽에 위치하면서 요리의 종류에 따라 메뉴 스트림을 세 개의 서브스트림으로 그룹화한다.
  • groupingBy 컬렉터는 collectingAndThen 컬렉터를 감싼다. 따라서 두 번째 컬렉터는 그룹화된 세 개의 서브스트림에 적용된다.
  • collectingAndThen 컬렉터는 세 번째 컬렉터 maxBy를 감싼다.
  • 리듀싱 컬렉터가 서브스트림에 연산을 수행한 결과에 collectingAndThen의 Optional::get 변환 함수가 적용된다.
  • groupingBy 컬렉터가 반환하는 맵의 분류 키에 대응하는 세 값이 각각의 요리 형식에서 가장 높은 칼로리다.

groupingBy와 함께 사용하는 다른 컬렉터 예제

일반적으로 스트림에서 같은 그룹으로 분류된 모든 요소에 리듀싱 작업을 수행할 때는 팩토리 메서드 groupingBy에 두 번째 인수로 전달한 컬렉터를 사용한다.

ex) 메뉴에 잇는 모든 요리의 칼로리 합계를 구하려고 만든 컬렉터 재사용

Map<Dish.Type, Integer> totalCaloriesByType =
    menu.stream().collect(groupingBy(Dish::getType, 
            summingInt(Dish::getCalories)));

이외에도 mapping 메서드로 만들어진 컬렉터도 groupingBy와 자주 사용된다.

mapping 메서드

• 인수: 스트림의 인수를 변환하는 함수, 변환 함수의 결과 객체를 누적하는 컬렉터
• 입력 요소를 누적하기 전에 매핑 함수를 적용해서 다양한 형식의 객체를 주어진 형식의 컬렉터에 맞게 변환

ex) 각 요리 형식에 존재하는 모든 CaloricLevel 값을 알고 싶을 때, groupingBy와 mapping 컬렉터를 합쳐 기능 구현 가능

Map<Dish.Type, Set<CaloricLevel>> caloricLevelsByType =
    menu.stream().collect(
        groupingBy(Dish::getType, mapping(dish -> {
            if (dish.getCalories() <= 400) return CaloricLevel.DIET;
            else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
            else return CaloricLevel.FAT; },
        toSet())));

mapping 메서드에 전달한 변환 함수는 Dish를 CaloricLevel로 매핑한다. CaloricLevel 결과 스트림은 toSet컬렉터로 전달되면서 리스트가 아닌 집합으로 스트림의 요소가 누적된다(중복값 저장x)

{OTHER=[DIET, NORMAL], MEAT=[DIET, NORMAL, FAT], FISH=[DIET, NORMAL]}

Set의 형식이 정해져 있지 않다. 이때 toCollection을 이용하면 원하는 방식으로 결과를 제어할 수 있다.

예를 들어 다음처럼 메서드 참조 HashSet::new를 toCollection에 전달할 수 있다.

Map<Dish.Type, Set<CaloricLevel>> caloricLevelsByType = 
    menu.stream().collect(
        groupingBy(Dish::getType, mapping(dish -> {
            if (dish.getCalories() <= 400) return CaloricLevel.DIET;
            else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
            else return CaloricLevel.FAT; }
        toCollection(HashSet::new))));

6.4 분할

: 분할 함수라 불리는 프레디케이트를 분류 함수로 사용하는 특수한 그룹화 기능

분할 함수는 Boolean을 반환하므로 맵의 키 형식은 Boolean이다. 결과적으로 그룹화 맵은 최대 (참 아니면 거짓의 값을 갖는) 두 개의 그룹으로 분류된다.

ex) 모든 요리를 채식 요리와 채식이 아닌 요리로 분류

Map<Boolean, List<Dish>> partitionedMenu =
    menu.stream().collect(partitioningBy(Dish::isVegetarian)); // 분할 함수

위 코드를 실행하면 다음과 같은 맵이 반환된다.

{false=[pork, beef, chicken, prawns, salmon],
 true=[french fries, rice, season fruit, pizza]}

이제 참값의 키로 맵에서 모든 채식 요리를 얻을 수 있다.

List<Dish> vegetarianDishes = partitionedMenu.get(true);

또는 메뉴 리스트로 생성한 스트림을 프레디케이트로 필터링한 다음에 별도의 리스트에 결과를 수집해도 같은 결과를 얻을 수 있다.

List<Dish> vegetarianDishes = 
    menu.stream().filter(Dish::isVegetarian).collect(toList());

6.4.1 분할의 장점

분할 함수가 반환하는 참, 거짓의 두 가지 요소의 스트림 리스트를 모두 유지한다는 것이 분할의 장점이다.

Map<Boolean, Map<Dish.Type, List<Dish>>> vegetarianDishesByType =
    menu.stream()
        .collect(partitioningBy(Dish::isVegetarian,           // 분할 함수
                                groupingBy(Dish::getType)));  // 두 번째 컬렉터

컬렉터를 두 번째 인수로 전달할 수 있는 오버로드된 버전의 partitioningBy 메서드이다.

{false=[FISH=[prawns, salmon], MEAT=[pork, beef, chicken]},
 true={OTHER=[french fries, rice, season fruit, pizza]}}

결과에서 확인할 수 있는 것처럼 채식 요리의 스트림과 채식이 아닌 요리의 스트림을 각각 요리 종류로 그룹화해서 두 수준의 맵이 반환되었다.

ex) 채식 요리와 채식이 아닌 요리 각각의 그룹에서 가장 칼로리가 높은 요리 찾기

Map<Boolean, Dish> mostCaloricPartitionedByVegetarian =
    menu.stream().collect(
            partitioningBy(Dish::isVegetarian, 
                            collectAndThen(maxBy(comparingInt(Dish::getCalories)),
															 Optional::get)));

다음은 프로그램 실행 결과다.

{false=pork, true=pizza}

• Quiz. partitioningBy 사용

  groupingBy 컬렉터와 마찬가지로 partitioningBy 컬렉터도 다른 컬렉터와 조합해서 사용할 수 있다. 특히 두 개의 partitioningBy 컬렉터를 이용해서 다수준 분할을 수행할 수 있다. 다음 코드의 다수준 분할 결과를 예측해보자.

    1. menu.stream().collect(partitioningBy(Dish::isVegetarian,
                                            partitioningBy(d -> d.getCalories() > 500)));
    2. menu.stream().collect(partitioningBy(Dish::isVegetarian,
                                            partitioningBy(Dish::getType)));
    3. menu.stream().collect(partitioningBy(Dish::isVegetarian,
                                            counting()));
  

  • 정답

    1. 유효한 다수준 분할 코드며, 다음과 같은 두 수준의 맵을 반환한다.

        {false={false=[chicken, prawns, salmon], true=[pork, beef]},
         true={false=[rice, season fruit], true=[french fries, pizza]}}
       

    2. partitioningBy는 불리언을 반환하는 함수, 즉 프레디케이트를 요구하므로 컴파일되지 않는 코드다. Dish::getType은 프레디케이트로 사용할 수 없는 메서드 참조다.

    3. 분할된 각 항목의 개수를 계싼하는 코드로 다음과 같은 맵을 반환한다.

        {false=5, true=4}
       

6.4.2 숫자를 소수와 비소수로 분할하기

정수 n을 인수로 받아서 2에서 n까지의 자연수를 소수와 비소수로 나누는 프로그램을 구현하자. 먼저 주어진 수가 소수인지 아닌지 판단하는 프레디케이트를 구현하면 편리할 것이다.

public boolean **isPrime**(int candidate) {
    return IntStream.range(2, candidate) // 2부터 candidate 미만 사이의 자연수 생성
                    .noneMatch(i -> candidate % i == 0); // 스트림의 모든 정수로 candidate를 나눌 수 없으면 참을 반환
}

다음처럼 소수의 대상을 주어진 수의 제곱근 이하의 수로 제한할 수 있다.

public boolean **isPrime**(int candidate) {
    int candidateRoot = (int) Math.sqrt((double)candidate);
    return IntStream.rangeClosed(2, candidateRoot)
                    .noneMatch(i -> candidate % i == 0);
}

이제 n개의 숫자를 포함하는 스트림을 만든 다음에 우리가 구현한 isPrime 메서드를 프레디케이트로 이용하고 partitioningBy 컬렉터로 리듀스해서 숫자를 소수와 비소수로 분류할 수 있다.

public Map<Boolean, List<Integer>> partitionPrimes(int n) {
    return IntStream.rangeClosed(2, n).boxed()
                    .collect(partitioningBy(candidate -> isPrime(candidate)));
}

6.5 Collector 인터페이스

Collector 인터페이스를 직접 구현해서 더 효율적으로 문제를 해결하는 컬렉터를 만드는 방법을 살펴보자.

다음 코드는 Collector 인터페이스의 시그니처와 다섯 개의 메서드 정의를 보여준다.

public interface Collector<T, A, R> {
    Supplier<A> supplier();
    BiConsumer<A, T> accumulator();
    Function<A, R> finisher();
    BinaryOperator<A> combiner();
    Set<Characteristics> characteristics();
}

• T는 수집될 스트림 항목의 제네릭 형식
• A는 누적자, 즉 수집 과정에서 중간 결과를 누적하는 객체의 형식
• R은 수집 연산 결과 객체의 형식(항상 그런 것은 아니지만 대개 컬렉션 형식)이다.

예를 들어 Stream의 모든 요소를 List로 수집하는 ToListCollector라는 클래스를 구현할 수 있다.

public class ToListCollector<T> implements Collector<T, List<T>, List<T>>

누적 과정에서 사용되는 객체가 수집 과정의 최종 결과로 사용된다.

6.5.1 Collector 인터페이스의 메서드 살펴보기

Colllector 인터페이스에 정의된 다섯 개의 메서드를 살펴보자.

먼저 살펴볼 네 개의 메서드는 collect 메서드에서 실행하는 함수를 반환하는 반면, 다섯 번째 메서드 characteristics는 collect 메서드가 어떤 최적화(ex. 병렬화)를 이용해서 리듀싱 연산을 수행할 것인지 결정하도록 돕는 힌트 특성 집합을 제공한다.

supplier 메서드 : 새로운 결과 컨테이너 만들기

supplier 메서드는 빈 결과로 이루어진 Supplier를 반환해야 한다.

즉, supplier는 수집 과정에서 빈 누적자 인스턴스를 만드는 파라미터가 없는 함수다.

ToListCollector처럼 누적자를 반환하는 컬렉터에서는 빈 누적자가 비어있는 스트림의 수집 과정의 결과가 될 수 있다. ToListCollector에서 supplier는 다음처럼 빈 리스트를 반환한다.

public Supplier<List<T>> supplier() {
    return () -> new ArrayList<T>();
}

생성자 참조를 전달하는 방법도 있다.

public Supplier<List<T>> supplier() {
    return ArrayList::new;
}

accumulator 메서드 : 결과 컨테이너에 요소 추가하기

accumulator 메서드는 리듀싱 연산을 수행하는 함수를 반환한다. 스트림에서 n번째 요소를 탐색할 때 두 인수, 즉 누적자(스트림의 첫 n-1개 항목을 수집한 상태)와 n번째 요소를 함수에 적용한다. 함수의 반환값은 void, 즉 요소를 탐색하면서 적용하는 함수에 의해 누적자 내부상태가 바뀌므로 누적자가 어떤 값일지 단정할 수 없다.

ToListCollector에서 accumulator가 반환하는 함수는 이미 탐색한 항목을 포함하는 리스트에 현재 항목을 추가하는 연산을 수행한다.

public BiConsumer<List<T>, T> accumulator() {
    return (list, item) -> list.add(item);
}

다음처럼 메서드 참조를 이용하면 코드가 더 간결해진다.

public BiConsumer<List<T>, T> accumulator() {
    return List::add;
}

finisher 메서드 : 최종 변환값을 결과 컨테이너로 적용하기

finisher 메서드는 스트림 탐색을 끝내고 누적자 객체를 최종 결과로 변환하면서 누적 과정을 끝낼 때 호출할 함수를 반환해야 한다. 때로는 ToListCollector에서 볼 수 있는 것처럼 누적자 객체가 이미 최종 결과인 상황도 있다. 이런 때는 변환 과정이 필요하지 않으므로 finisher 메서드는 항등 함수를 반환한다.

public Function<List<T>, List<T>> finisher() {
    return Function.identity();
}

지금까지 살펴본 세 가지 메서드로도 순차적 스트림 리듀싱 기능을 수행할 수 있다. 실제로는 collect가 동작하기 전에 다른 중간 연산과 파이프라인을 구성할 수 있게 해주는 게으른 특성 그리고 병렬 실행 등도 고려해야 하므로 스트림 리듀싱 기능 구현은 생각보다 복잡하다.

combiner 메서드 : 두 결과 컨테이너 병합

combiner 메서드는 마지막으로 리듀싱 연산에서 사용할 함수를 반환한다.

combiner의 스트림은 서로 다른 서브파트를 병렬로 처리할 때 누적자가 이 결과를 어떻게 처리할지 정의한다. toList의 combiner는 비교적 쉽게 구현할 수 있다. 즉, 스트림의 두 번째 서브 파트에서 수집한 항목 리스트를 첫 번째 서브파트 결과 리스트의 뒤에 추가하면 된다.

public BinaryOperator<List<T>> combiner() {
    return (list1, list2) -> {
        list1.addAll(list2);
        return list1;
    }
}

combiner 메서드를 이용하면 스트림의 리듀싱을 병렬로 수행할 수 있다.

• 스트림을 분할해야 하는지 정의하는 조건이 거짓으로 바뀌기 전까지 원래 스트림을 재귀적으로 분할한다(보통 분산된 작업의 크기가 너무 작아지면 병렬 수행의 속도는 순차 수행의 속도보다 느려진다. 즉, 병렬 수행의 효과가 상쇄된다. 일반적으로 프로세싱 코어의 개수를 초과하는 병렬 작업은 효율적이지 않다.)
• 그림에서 보여주는 것처럼 모든 서브스트림의 각 요소에 리듀싱 연산을 순차적으로 적용해서 서브스트림을 병렬로 처리할 수 있다.
• 마지막에는 컬렉터의 combiner 메서드가 반환하는 함수로 모든 부분결과를 쌍으로 합친다. 즉, 분할된 모든 서브스트림의 결과를 합치면서 연산이 완료된다.

Characteristics 메서드

characteristics 메서드는 컬렉터의 연산을 정의하는 Characteristics 형식의 불변 집합을 반환한다.

스트림을 병렬로 리듀스할 것인지 그리고 병렬로 리듀스한다면 어떤 최적화를 선택해야 할지 힌트를 제공한다.

Characteristics는 다음 세 항목을 포함하는 열거형이다.

• UNORDERED

  : 리듀싱 결과는 스트림 요소의 방문 순서나 누적 순서에 영향을 받지 않는다.

• CONCURRENT

  : 다중 스레드에서 accumulator 함수를 동시에 호출할 수 있으며 이 컬렉터는 스트림의 병렬 리듀싱을 수행할 수 있다. 컬렉터의 플래그에 UNORDERED를 함께 설정하지 않았다면 데이터 소스가 정렬되어 있지 않은(즉, 집합처럼 요소의 순서가 무의미한) 상황에서만 병렬 리듀싱을 수행할 수 있다.

• IDENTITY_FINISH

  : finisher 메서드가 반환하는 함수는 단순히 identity를 적용할 뿐이므로 이를 생략할 수 있다. 따라서 리듀싱 과정의 최종 결과로 누적자 객체를 바로 사용할 수 있다. 또한 누적자 A를 결과 R로 안전하게 형변환할 수 있다.

ToListCollector에서 스트림의 요소를 누적하는 데 사용한 리스트가 최종 결과 형식이므로 추가 변환이 필요없다.

따라서 ToListCollector는 IDENTITY_FINISH다. 하지만 리스트의 순서는 상관이 없으므로 UNORDERED다. 마지막으로 ToListCollector는 CONCURRENT다.

요소의 순서가 무의미한 데이터 소스여야 병렬로 실행할 수 있다.

6.5.2 응용하기

커스텀 ToListCollector 구현하기

import java.util.*;
import java.util.function.*;
import java.util.stream.Collector;
import static java.util.stream.Collector.Characteristics.*;

public class ToListCollector<T> implements Collect<T, List<T>, List<T>> {
    @Override
    public Supplier<List<T>> supplier() {
        return ArrayList::new; // 수집 연산의 시발점
    }

    @Override
    public BiConsumer<List<T>, T> accumulator() {
        return List::add; // 탐색한 항목을 누적하고 누적자를 고친다
    }
    
    @Override
    public Function<List<T>, List<T>> finisher() {
        return Function.identity(); // 항등 함수
    }

    @Override
    public BinaryOperator<List<T>> combiner() {
        return (list1, list2) -> { // 두 번째 콘텐츠와 합쳐서 첫 번째 누적자를 고친다. 
            list1.addAll(list2);  // 변경된 첫 번째 누적자를 반환한다. 
            return list1;
        };
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(
            IDENTITY_FINISH, CONCURRENT)); // 컬렉터의 플래그를 IDENTITY_FINISH, CONCURRENT로 설정
    }
}

위 구현이 Collectors.toList 메서드가 반환하는 결과와 완전히 같은 것은 아니지만 사소한 최적화를 제외하면 대체로 비슷하다. 특히 자바 API에서 제공하는 컬렉터는 싱글톤 Collections.emptyList()로 빈 리스트를 반환한다.

이제 자바에서 제공하는 API 대신 우리가 만든 컬렉터를 메뉴 스트림의 모든 요리를 수집하는 예제에서 사용가능하다.

List<Dish> dishes = menu.stream.collect(new ToListCollector<Dish>());

다음은 기존의 코드다.

List<Dish> dishes = menuStream.collect(toList());

기존 코드의 toList는 팩토리지만 우리 ToListCollector는 new로 인스턴스화한다는 점이 다르다.

컬렉터 구현을 만들지 않고도 커스텀 수집 수행하기

IDENTITY_FINISH 수집 연산에서는 Collector 인터페이스를 완전히 새로 구현하지 않고도 같은 결과를 얻을 수 있다. Stream은 세 함수 (발행, 누적, 합침)을 인수로 받는다.