[Java] Stream Collector, Downstream Collector

개요

Stream은 중간 연산을 거친 데이터들을 collect 최종 연산을 통해 다양한 컬렉션으로 반환할 수 있다. 

 

 

구조

public interface Stream<T> extends BaseStream<T, Stream<T>> {
	..
	
    //Collector 인터페이스를 통해 최종 연산 반환 타입 지정
    <R, A> R collect(Collector<? super T, A, R> collector);
    
    ..
}

collect 연산은 Collector 인터페이스을 매개변수로 받아서 알맞은 컬렉션 형태로 반환한다.

 

자바에서 Collectors 클래스를 통해 Collector 인터페이스의 대부분 기능을 구현해 놓았다. Collectors 클래스에서 어떤 기능들로 어떤 타입들을 반환하는지 알아보자.

 

 

List 반환

//수정 가능
List<String> list = Stream.of("Java", "Spring", "JPA")
		.collect(Collectors.toList());
        
//수정 불가능
List<Integer> unmodifiableList = Stream.of(1, 2, 3)
		.collect(Collectors.toUnmodifiableList());

toList() 메서드와 toUnmodifiableList() 메서드로 리스트 반환이 가능하다. 둘은 수정 가능 여부에 차이가 있다. 

 

//Java 17부터 더 간략하게 가능        
List<Integer> unmodifiableList2 = Stream.of(1, 2, 3)
		.toList();

Java 17부터는 아예 toList() 최종 연산을 지원한다. 해당 최종 연산을 통해 반환되는 결과는 수정이 불가능하니 이 점 주의하자.

 

 

Set 반환

//수정 가능
Set<Integer> set = Stream.of(1, 2, 2, 3, 3, 3)
		.collect(Collectors.toSet());

//수정 불가능
Set<Integer> unmodifiableSet = Stream.of(1, 2, 2, 3, 3, 3)
		.collect(Collectors.toUnmodifiableSet());

동일하게 Collectors 클래스에서 제공하는 메서드로 간단하게 Set 타입으로 반환이 가능하다.

 

//타입 지정
TreeSet<Integer> treeSet = Stream.of(3, 4, 5, 2, 1)
		.collect(Collectors.toCollection(TreeSet::new));

Treeset, HashSet 등의 타입을 지정할 수도 있다.

 

 

Map 반환

//수정 가능
Map<String, Integer> map = Stream.of("Apple", "Banana", "Tomato")
		.collect(Collectors.toMap(
				// key
				name -> name,
				// value
				name -> name.length()
		));

//수정 불가능
Map<String, Integer> unModifiedableMap = Stream.of("Apple", "Banana", "Tomato")
		.collect(Collectors.toUnmodifiableMap(
				name -> name, // keyMapper
				name -> name.length() // valueMapper
		));

Map 타입에 대한 메서드도 지원한다.

 

//키 중복 대안
Map<String, Integer> alternativeKeyMap = Stream.of("Apple", "Apple", "Tomato")
		.collect(Collectors.toMap(
				name -> name,
				name -> name.length(),
                
				// 중복될 경우 -> 기존 값 + 새 값
				(oldVal, newVal) -> oldVal + newVal 
		));

Map에 key는 유니크하다. key가 중복될 경우, 그에 대한 대체도 지정할 수 있다.

 

//Map의 타입 지정
Map<String, Integer> typeMap = Stream.of("Apple", "Apple", "Tomato")
		.collect(Collectors.toMap(
				name -> name,
				name -> name.length(),
				(oldVal, newVal) -> oldVal + newVal,
                
				// 타입 지정
				LinkedHashMap::new
		));

Map에 타입도 지정할 수 있다.

 

 

그룹핑과 파티셔닝

그룹핑

List<String> names = List.of("Apple", "Avocado", "Banana", "Blueberry", "Cherry");

// 람다식을 기준으로 그룹화
Map<String, List<String>> grouped = names.stream()
		.collect(Collectors.groupingBy(name -> name.substring(0, 1)));

groupingBy() 매개변수로 람다식을 전달하여, 해당 람다식 수행 후 결과값이 동일한 데이터들을 그룹화 한 Map을 반환할 수 있다.

 

파티셔닝

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);

// 조건을 기준으로 요소 분할
Map<Boolean, List<Integer>> partitioned = numbers.stream()
		.collect(Collectors.partitioningBy(n -> n % 2 == 0));

partitioningBy() 매개변수로 Boolean 람다식을 전달하여, 해당 조건에 조합하는지 안하는지에 따라 이분화 한 Map을 반환할 수 있다.

 

 

Downstream Collector (다운 스트림 컬렉터)

위에서 그룹핑 혹은 파티셔닝을 통해 Map 타입을 반환받았다.

grouping() 메서드와 partitioningBy() 메서드를 살펴보면, 반환 타입인 Map의 value는 List 타입으로 그룹화 된 결과를 나타낸다. 

그룹화 된 결과 컬렉션에 대해 추가로 어떻게 처리할 지 정의하는 것을 다운 스트림 컬렉터라고 한다.

 

너무 막연하니 예시로 살펴보자.

 

데이터 셋

@Getter
public class Student {
    private String name;
    private int grade;
    private int score;

    public Student(String name, int grade, int score) {
        this.name = name;
        this.grade = grade;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", grade=" + grade +
                ", score=" + score +
                '}';
    }
}

=================

List<Student> students = List.of(
        new Student("Kim", 1, 85),
        new Student("Park", 1, 70),
        new Student("Lee", 2, 70),
        new Student("Han", 2, 90),
        new Student("Hoon", 3, 90),
        new Student("Ha", 3, 89)
);

Student 객체가 있고, Student List를 정의하였다.

 

//Grade 별로 그룹핑
Map<Integer, List<Student>> grouped = students.stream()
        .collect(Collectors.groupingBy(
                Student::getGrade 
        ));
System.out.println("grouped = " + grouped);

학생들에 대해 Grade 별로 그룹핑 할 수 있다.

 

grouped = {1=[Student{name='Kim', grade=1, score=85}, Student{name='Park', grade=1, score=70}], 
           2=[Student{name='Lee', grade=2, score=70}, Student{name='Han', grade=2, score=90}], 
           3=[Student{name='Hoon', grade=3, score=90}, Student{name='Ha', grade=3, score=89}]
           }

출력 결과를 보면, Grade 별로 학생들이 그룹핑 된 것을 볼 수 있다.

 

그룹화 된 데이터 변환

//Grade 별로 그룹핑
Map<Integer, List<Student>> groupedMapping = students.stream()
        .collect(Collectors.groupingBy(
                Student::getGrade,
                
                //그룹화 된 리스트를 변환
                //name으로 변환
                Collectors.mapping(
                	Student::getName,
                	Collectors.toList())
        ));
System.out.println("groupedMapping = " + groupedMapping);

collect의 매개변수로 그룹화 된 컬렉션을 어떻게 처리할지 Collector를 통해 정의하였다.

각 객체의 이름으로 리스트를 구성하도록 정의하였다.

 

groupedMapping = {1=[Kim, Park], 2=[Lee, Han], 3=[Hoon, Ha]}

그룹핑 된 데이터가 name으로 변환되었다.

 

그룹화 된 데이터 통계

Map<Integer, List<Student>> groupedCount = students.stream()
        .collect(Collectors.groupingBy(
                Student::getGrade,
                
                //그룹화 별 갯수
                Collectors.counting()
        ));


Map<Integer, List<Student>> groupedAverage = students.stream()
        .collect(Collectors.groupingBy(
                Student::getGrade,
                
                //그룹화 별 점수 평균
                Collectors.averagingInt(Student::getScore)
        ));        
        

System.out.println("groupedCount = " + groupedCount);
System.out.println("groupedAverage = " + groupedAverage);

그룹화 된 컬렉션에 대한 갯수나 특정 필드의 평균을 구하는 등, 통계를 구하는데도 아주 유연하다.

 

groupedCount = {1=2, 2=2, 3=2}
groupedAverage = {1=77.5, 2=80.0, 3=89.5}

 

결과는 다음과 같이 출력되었다.

 

그룹화 된 데이터에 대한 후처리

Map<Integer, List<Student>> groupedAndThen = students.stream()
        .collect(Collectors.groupingBy(
                Student::getGrade,
                
                //그룹화 된 리스트에 대한 후처리
                Collectors.collectingAndThen(
                        //점수가 가장 높은 학생에 대해
                        Collectors.maxBy(Comparator.comparingInt(Student::getScore)),
                        //해당 학생의 이름을 반환
                        sOpt -> sOpt.get().getName()
                )
        ));
System.out.println("groupedAndThen = " + groupedAndThen);

 

그룹핑 된 리스트에 대해 추가적인 복잡한 후처리 로직도 작성 가능하다.

위 코드에서는 각 그룹 별 점수가 가장 높은 학생의 이름을 출력하도록 후처리 로직을 작성하였다.

 

groupedAndThen = {1=Kim, 2=Han, 3=Hoon}

결과를 통해 각 그룹 별 점ㅅ가 가장 높은 학생의 이름만 저장되었다.

 

 

정리

Stream의 Collector부터 다운 스트림 컬렉터까지 알아보았다. Collector와 다운 스트림을 이용하면 특정 데이터들에 대한 처리나 복잡한 통계같은 것도 유연하게 처리가 가능할 것 같다.

Stream Collector는 위에서 설명한 것 외에도 다양한 API를 제공해주기 때문에, 모든 기능에 대해서 외우기보다는 각각의 상황에 맞게 찾아서 사용해보자.