[JAVA] Java Stream groupingBy 통해 그룹핑하기

Stream(). collect()

stream(). collect()는 데이터의 중간 처리 후 마지막에 원하는 형태로 변환해 주는 역할을 합니다.

• stream 요소들을 List, Set, Map 자료형으로 변환
• stream 요소들의 결합 (joining)
• stream 요소들의 통계 (최대, 최소, 평균값)
• stream 요소들의 그룹화와 분할

 

Collectors.toList()

모든 Stream의 요소를 List 인스턴스로 수집하는 데 사용합니다.

stream().collect(Collectors.toList());
stream().toList();

 

Collectors.groupingBy()

Collectors의 groupingBy()는 일부 속성 별로 객체를 그룹핑하고 결과를 Map 인스턴스에 저장하는 데 사용됩니다.

1. groupingBy(Function <T, K> classifier)

• 매개 변수 Function<T, K> classifier
• 리턴 타입 Collector <T,?, Map <K, List <T>>>

T를 K로 매핑한다.
키가 K이면서 T를 저장하는 요소를 값으로 갖는 Map을 생성한다.

 

example

Map<Student.Sex, List<Student>> studentList.stream()
	.collect(Collectors.groupingBy(Student::getSex));

• Student의 Sex을 기준으로 grouping
• Function <T, K>를 매개변수로 사용 --> T(Student)를 K(Sex)로 매핑

 

2. groupingBy(Function <T, K> classifier, Collector <T, A, D> downstream)

groupingBy(Function<T, K> classifier, Collector<T, A, D> downstream)

• 매개 변수 Function<T, K> classifier, Collector<T, A, D> collector
• 리턴 타입 Collector <T,?, Map <K, D>>

classifier (Function <T, K>)

• 스트림의 각 요소를 분류할 기준을 제공하는 함수입니다. 이 함수는 스트림의 각 요소를 받아서 특정 키(K)로 매핑합니다.

downstream (Collector <T, A, D>)

• 그룹화된 각 키에 해당하는 값들에 대해 추가적인 수집 작업을 정의합니다. 그룹화된 각 그룹의 값들이 이 Collector를 통해 처리된 결과를 D로 반환합니다.
• 이 매개변수로 Collectors.toList()를 사용하면, 각 그룹화된 키에 대해 해당 키에 속하는 요소들이 리스트로 수집됩니다.

T를 K로 매핑한다.
키가 K이면서 키에 저장된 D객체에 T를 누적한 Map을 생성한다.

 

example

Map<Student.City, List<String>> mapByCity = studentList.stream()
	.collect(Collectors.groupingBy(
    		Student::getCity,
            Collectors.mapping(Student::getName, Collectors.toList()))
   	);

• Student의 City를 기준으로 grouping
• T(Student)를 K(City)로 매핑
• Key가 K(City)이면서 Key에 저장된 T(Student) 객체에 A(Name)를 수집한 Map(D)을 생성

 

테스트 코드

void groupby() {

        // given
        List<Order> orders = getOrders();

        // 단일키 그룹핑
        System.out.println("단일키 그룹핑");
        Map<OrderType, List<Order>> collect = orders.stream()
                .collect(groupingBy(Order::getOrderType));

        List<Order> orderList = collect.get(OrderType.DELIVERY);

        for (Order order : orderList) {
            System.out.println("order.getItemName() = " + order.getItemName());
        }

        // 그룹핑 & 매핑
        System.out.println("그룹핑 + 매핑");
        Map<OrderType, List<String>> typeListMap = orders.stream()
                .collect(groupingBy(
                        Order::getOrderType,
                        mapping(Order::getItemName, toList())));

        typeListMap.forEach((type, itemNames) -> {
            System.out.println("type = " + type);
            System.out.println("Items: " + String.join(", ", itemNames));
        });

        // 그룹핑 2번
        System.out.println("그룹핑 2번");
        Map<String, Map<OrderType, List<Order>>> orderByMap = orders.stream()
                .collect(groupingBy(Order::getOrderBy, groupingBy(Order::getOrderType)));

        orderByMap.entrySet()
                .forEach(entry -> {
                    String orderBy = entry.getKey();
                    Map<OrderType, List<Order>> ordersByType = entry.getValue();
                    System.out.println("orderBy = " + orderBy);
                    ordersByType.entrySet()
                            .forEach(innerEntry -> {
                                System.out.println("innerEntry.getKey() = " + innerEntry.getKey());
                                innerEntry.getValue().forEach(order ->
                                        System.out.println(
                                                "order.getItemName() = " + order.getItemName()));
                            });
                });

    }