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

6.1 컬렉터란 무엇인가?

함수형 프로그래밍에서는 ‘무엇’을 원하는지 직접 명시할 수 있어 어떠한 방법으로 이를 얻을지는 신경 쓸 필요가 없다.

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

스트림에 collect 를 호출하면 스트림의 요소에 리듀싱 연산이 수행된다.

명령형 프로그래밍에서 우리가 직접 구현해야 했던 작업이 자동으로 수행된다.

보통 함수를 요소로 변환할 때 컬렉터를 적용하며 최종 결과를 저장하는 자료구조에 값을 누적한다.

예를 들어 가장 많이 사용하는 직관적인 정적 메서드로 toList 는 스트림의 모든 요소를 리스트로 수집한다.

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

6.1.2 미리 정의된 컬렉터

Collectors 에서 제공하는 메서드의 기능은 크게 세 가지로 구분할 수 있다.

• 스트림 요소를 하나의 값으로 리듀스하고 요약
• 요소 그룹화
• 요소 분할

6.2 리듀싱과 요약

컬렉터로 스트림의 항목을 컬렉션으로 재구성할 수 있다.

즉 컬렉터로 스트림의 모든 항목을 하나의 결과로 합칠 수 있다.

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

->

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

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

Collectors.maxBy Collectors.minBy 는 스트림의 최댓값과 최솟값을 계산할 수 있다.

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

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

6.2.2 요약 연산

Collectors.summingInt 라는 요약 팩터리 메서드는 객체를 int 로 매핑하는 함수를 인수로 받는다.

이 인수로 전달된 함수는 객체를 int 로 매핑한 컬렉터를 반환한다.

그리고 summingInt 가 collect 메서드로 전달되면 요약 작업을 수행한다.

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

Collectors.summingLong 과 Collectors.summingDouble 메서드도 같은 방식으로 동작한다.

평균값 계산 등의 연산 요약 기능도 제공된다.

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

두 개 이상의 요약 연산을 한 번에 수행해야 할 때는 summarizingInt 가 반환하는 컬렉터를 사용할 수 있다.

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

menuStatistics 객체를 출력하면 다음과 같은 정보가 확인된다.

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

6.2.3 문자열 연결

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

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

내부적으로 StringBuilder 를 이용해서 문자열을 하나로 만든다.

두 요소 사이에 구분 문자열을 넣을 수 있도록 오버로드된 joining 도 제공한다.

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

6.2.4 범용 리듀싱 요약 연산

Collectors.reducing 으로도 이들을 정의할 수 있다.

특화된 컬렉터를 사용한 이유는 프로그래밍적 편의성 때문이다.

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

reducing 은 세 개의 인수를 받는다.

1. 리듀싱 연산의 시작값 또는 스트림에 인수가 없을 때는 반환값
2. 변환 함수
3. 같은 종류의 두 항목을 하나의 값으로 연산하는 Operator

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

만약 reducing 이 한 개의 인수를 가지면 스트림의 첫 번째 요소를 시작 요소 (1번째 인수) 로 받는것,

그리고 자신을 그대로 반환하는 항등 함수를 두 번째 인수로 받는 것으로 간주한다.

그래서 만약 빈 스트림이 넘겨지면 시작값이 설정되지 않는 상황이 벌어지기 때문에 Optional 을 반환한다.

reducing 에서 람다 대신 Integer 함수를 써서 더 간단하게 만들 수도 있다.

int totalCalories = menu.stream().collect(reducing(0, 
																	Dish::getCalories,
																	Integer::sum));

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

6.3 그룹화

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

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

groupingBy 함수를 기준으로 스트림이 그룹화되므로 이를 분류 함수라고 부른다.

단순한 속성 접근자 대신 더 복잡한 분류 기준이 필요한 상황에서는 메서드 참조를 분류 함수로 사용할 수 없다.

대신 람다 표현식으로 이를 구현할 수 있다.

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 그룹화된 요소 조작

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

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

이 코드의 단점은 없는 결과에 대해서는 Key 자체가 사라진다는 점이다.

그래서 groupingBy 팩토리 메서드를 오버로드해 이 문제를 해결한다.

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

filtering 메서드는 Collectors 클래스의 또 다른 정적 팩토리 메서드로 프레디케이트를 인수로 받아 재그룹화 한다.

그래서 비어있는 목록도 항목으로 추가된다.

mapping 메서드는 그룹의 각 요리를 관련 이름 목록으로 변환할 수 있다.

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

flatMapping 컬렉터를 이용하면 집합으로 그룹화하고 중복을 제거할 수 있다.

Menu<Dish.Type, Set<String>> dishNamesByType = 
		menu.stream()
				.collect(groupingBy(Dish::getType,
								flatMapping(Dish::getName).stream(), toSet())));

6.3.2 다수준 그룹화

groupingBy 를 이용해 항목을 다수준으로 그룹화할 수 있다.

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

n 수준 그룹화의 결과는 n 수준 트리 구조로 표현되는 n 수준 맵이 된다.

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

groupingBy 로 넘겨주는 컬렉터의 형식은 제한이 없다.

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

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

팩토리 메서드 collectingAndThen 은 적용할 컬렉터와 변환함수를 받아 다른 컬렉터를 반환한다.

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

6.4 분할

분할은 분할 함수라 불리는 프레디케이트를 분류 함수로 사용한다.

분할 함수는 Boolean 을 기준으로 나뉜 참, 거짓 그룹으로만 분리된다.

Map<Boolean, List<Dish>> partitionedMenu = 
		menu.stream().collect(partitioningBy(Dish::isVegerarian));

6.4.1 분할의 장점

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

컬렉터를 두 번째 인수로 전달할 수 있는 오버로드된 버전도 있다.

Map<Boolean, Map<Dish.Type, List<Dish>>> vegetarianDishesByType = 
		menu.stream().collect(
					partitioningBy(Dish::isVegerarian,
												groupingBy(Dish::getType)));

이를 이용하여 채식 요리와 채식이 아닌 요리 각각의 그룹에서 가장 칼로리가 높은 요리도 찾을 수 있다.

Map<Boolean, Map<Dish.Type, List<Dish>>> vegetarianDishesByType = 
		menu.stream().collect(
					partitioningBy(Dish::isVegerarian,
							collectingAndThen(maxBy(comparingInt(Dish::getCalories)),
																Optional.get)));

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

public boolean isPrime(int candidate) {
		return IntStream.range(2, candidate)
										.nonMatch(i -> candidate % i == 0);
}

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 : 수집 연산 결과 객체의 형식 (대게 컬렉션)

우리가 만들어볼 콜렉터의 형식은 이렇다.

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

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

• Supplier

supplier 메서드는 빈 누적자 인스턴스를 만드는 파라미터가 없는 함수이다.

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

• Acuumulator

accumulator 메서드는 리듀싱 연산을 수행하는 함수를 반환한다.

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

• Finisher

finisher 메서드는 스트림 탐색을 끝내고 누적자 객체를 최종 결과로 반환하면서 누적 과정을 끝낼 때 호출할 함수를 반환해야 한다.

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

• Combiner

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

스트림의 서로 다른 서브파트를 병렬로 처리할 때 누적자가 이 결과를 어떻게 처리할지 정의한다.

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

• Characteristics

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

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

• UNORDERED : 리듀싱 결과는 스트림 요소 방문 순서나 누적 순서에 영향받지 않음
• CONCURRENT : 다중 스레드에서 acuumulator 함수를 동시에 호출할 수 있으며 병렬 리듀싱을 수행할 수 있다.
• IDENTITY_FINISH : finisher 메서드가 반환하는 함수는 단순히 identity 를 적용할 뿐이므로 이를 생략할 수 있다.

이제 우리가 만든 컬렉터를 예제에 사용할 수 있다.

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