[04] Collector

🔮 Collector

Collector 인터페이스의 구현은 Stream의 요소를 어떤 식으로 도출할지 지정한다.

고급 Reducing

Stream에서 collect로 결과를 수집하는 과정에서 Collector를 이용하여 고수준의 Reducing을 쉽게 할 수 있다. Collectors 유틸리티 Class는 자주 사용하는 Collector 인스턴스를 손쉽게 생성할 수 있는 정적 Factory Method를 제공한다.

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

미리 정의된 Collector

Collectors에서 제공하는 Factory Method의 기능은 3가지로 구분한다.

1. Stream 요소를 하나의 값으로 Reducing & Summarize
2. 요소 Grouping
3. 요소 Partitioning

Factory Method	Return Type	Example
toList	List<T>	스트림의 모든 요소를 리스트로 수집
toSet	Set<T>	스트림의 모든 요소를 집합으로 수집
toCollection	Collection<T>	스트림의 모든 요소를 특정 Collection으로 수집
counting	Long	스트림의 모든 요소의 갯수를 반환
summingInt/Double/Long	Integer/Double/Long	스트림의 요소의 속성값을 더함
averageInt/Double/Long	Integer/Double/Long	스트림의 요소의 속성 평균값을 계산
summarizingInt/Double/Long	Integer/Double/Long	스트림의 요소의 최댓값, 최솟값, 합계, 평균 등의 정보 통계 수집
joining	String	스트림의 모든 요소의 toString()을 호출하여 연결
maxBy	Optional<T>	주어진 Comparator를 이용해서 스트림의 최댓값 요소를 Optional로 감싼 값으로 반환
minBy	Optional<T>	주어진 Comparator를 이용해서 스트림의 최솟값 요소를 Optional로 감싼 값으로 반환
reducing		누적자를 초깃값으로 설정한 다음에 BinaryOperator로 스트림의 각 요소를 반복적으로 누적자와 합쳐 스트림을 하나의 값으로 Reducing
collectingAndThen		다른 Collector를 감싸고 그 결과에 변환 함수 적용
groupingBy	Map<Key, List<T>>	하나의 속성값을 기준으로 스트림의 요소를 그룹화하며 기준 속성값을 결과 맵의 키로 사용
partitioningBy	Map<Boolean, List<T>>	Predicate를 스트림의 각 요소에 적용한 결과로 요소 분할

---

🌸 Reducing & Summarize

1. Collectors.counting()

Stream에서 요소의 개수를 반환한다.

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

2. Collectors.maxBy(), Collectors.minBy()

Stremam의 최댓값과 최솟값을 반환한다.

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

-- Collectors.maxBy()
Optional<Dish> mostCaloriesDish = menu.stream().collect(Collectors.maxBy(dishCaloriesComparator));

-- Collectors.minBy()
Optional<Dish> leastCaloriesDish = menu.stream().collect(Collectors.minBy(dishCaloriesComparator));

3. 합계

• Collectors.summingInt(ToIntFunction<T>)
• Collectors.summingDoulbe(ToDoubleFunction<T>)
• Collectors.summingLong(ToLongFunction<T>)

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

4. 평균

• Collectors.averagingInt(ToIntFunction<T>)
• Collectors.averagingDoulbe(ToDoubleFunction<T>)
• Collectors.averagingLong(ToLongFunction<T>)

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

5. 모든 정보

count, min, max, sum, average를 모두 반환하는 SummaryStatistics 클래스를 반환한다.

• Collectors.summarizingInt(ToIntFunction<T>) : IntSummaryStatistics
• Collectors.summarizingDoulbe(ToDoubleFunction<T>) : DoubleSummaryStatistics
• Collectors.summarizingLong(ToLongFunction<T>) : LongSummaryStatistics

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

6. Collectors.joining()

Stream의 각 객체에 toString() 메서드를 호출하여 모든 문자열을 하나의 문자열로 연결하여 반환한다.
joining 메서드는 내부적으로 StringBuilder를 이용하여 문자열을 하나로 만들며 (구분자, Prefix, Postfix)를 인수로 전달한다.

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

7. Collectors.reducing()

-- 합계
int totalCalories =
		menu.stream()
			.collect(Collectors.reducing(0, Dish::getCalories, (s, t) -> s + t));

-- 합계 - Integer 클래스 sum 사용
int totalCalories =
		menu.stream()
			.collect(Collectors.reducing(0, Dish::getCalories, Integer::sum));

-- 최댓값
Optional<Dish> mostCaloriesDish =
		menu.stream()
			.collect(Collectors.reducing((i, j) -> i.getCalories() < j.getCalories() ? j : i));

---

👪 Grouping

1. Collectors.grouping()

Classification Function (분류 함수)로 Stream 요소를 그룹화 할 수 있다.

-- 기본 사용법
Map<Dish.Type, List<Dish>> dishesByType = menu.stream().collect(Collectors.groupingBy(Dish::getType));

2. Collectors.filtering()

Java SE 9에 추가된 Collectors.filtering 메서드로 요소들의 조건도 추가할 수 있다.

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

3. Collectors.mapping()

Collectors 클래스는 매핑 함수와 각 항목에 적용한 함수를 모으는 데 사용하는 또 다른 컬렉터를 인수로 받는 mpaaing 메서드를 제공한다.

-- Collectors.mapping 사용
Map<Dish.Type, List<Dish>> caloricDishesByType =
		menu.stream().collect(
				Collectors.groupingBy(
						Dish::getType,
						Collectors.mapping(Dish::getName, Collectors.toList())
				)
		);

4. Collectors.flatMapping()

Java SE 9에 추가된 Collectors.flatMapping 메서드로 두 수준의 리스트를 한 수준으로 평면화하기 위해 사용한다.

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

5. 다수준 Grouping

groupingBy 메서드를 중첩 사용하여 다수준으로 스트림의 항목을 그룹화할 수 있다. n수준 그룹화의 결과는 n수준 트리 구조로 표현되는 n수준 맵이 된다.

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

6. 서브 그룹으로 데이터 수집

-- 타입별 음식 갯수
Map<Dish.Type, Long> typesCount =
		menu.stream().collect(Collectors.groupingBy(Dish::getType, Collectors.counting()));

-- 타입별로 가장 높은 칼로리를 가진 음식
Map<Dish.Type, Optional<Dish>> mostCaloricByType =
		menu.stream().collect(
				Collectors.groupingBy(
						Dish::getType, 
						Collectors.maxBy(Comparator.comparingInt(Dish::getCalories))
				)
		);

7. Collectors.collectingAndThen()

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

-- 컬렉터 결과를 다른 형식에 적용
Map<Dish.Type, Dish> mostCaloricByType =
		menu.stream().collect(
				Collectors.groupingBy(
						Dish::getType,
						Collectors.collectingAndThen(
								Collectors.maxBy(Comparator.comparingInt(Dish::getCalories)), 
								Optional::get
						)
				)
		);

---

🐥 Partitioning

Partitioning Function (분할 함수)라 불리는 Predicate를 분류 함수로 사용하는 특수한 그룹화 기능이다. 분할 함수는 Boolean을 반환하므로 맵의 키 형식은 Boolean이며 두 그룹(True or False)으로 나누어진다.

Collectors.partitioningBy()

-- 기본 사용법
Map<Boolean, List<Dish>> partitionedMenu =
		menu.stream().collect(Collectors.partitioningBy(Dish::isVegetarian));

-- groupingBy와 같이 사용
Map<Boolean, Map<Dish.Type, List<Dish>>> vegetarianDishesByType =
		menu.stream().collect(
				Collectors.partitioningBy(
						Dish::isVegetarian,
						Collectors.groupingBy(Dish::getType)
				)
		);

---

Collector Interface

Collector Interface는 아래와 같다.

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

• T는 수집될 스트림 요소의 Generic Type이다.
• A는 Accumulator(누적자), 즉 수집 과정에서 중간 결과를 누적하는 객체의 형식이다.
• R은 수집 연산 결과 객체의 형식이다.

1. supplier : 새로운 결과 컨테이너 만들기

빈 결과로 이루어진 Supplier를 반환하며, 수집 과정에서 빈 누적자 인스턴스를 만드는 파라미터가 없는 함수이다.

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

2. accumulator : 결과 컨테이너에 요소 추가하기

Reducing 연산을 수행하는 함수를 반환하며, 스트림에서 n번째 요소를 탐색할 때 두 인수(누적자와 n번째 요소)를 함수에 적용한다.

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

3. finisher : 최종 변환값을 결과 컨테이너에 적용하기

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

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

4. combiner : 두 결과 컨테이너 병합

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

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

5. characteristics

Collector의 연산을 정의하는 Characteristics 형식의 불변 집합을 반환한다.

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

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

-- 커스텀 toList 구현
public class ToListCollector<T> implements Collector<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 EnumSet.of(Characteristics.IDENTITY_FINISH, Characteristics.CONCURRENT);
	}
}

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

---