2 Weeks - [Collectors.toMap에 대해 궁금합니다]

[dpwns523]

문제

컬렉터의 toMap 메서드에 대해 알아보기

contents - 세부 내용

그룹화 메서드로 Collectors.toMap을 이용하는 방법도 있는데 책에서는 소개되지 않아서 알아보는게 좋을 것 같습니다

• toMap 메서드의 구현, 내부 동작
• groupingBy, partitioningBy의 차이, toMap으로 구현할 수 있을까?

  참고

  6.3 ~ 6.5절

[hgene0929]

Stream.collect()

• 역할 : 데이터의 중간 처리 후 마지막에 원하는 형태로 변환해주는 역할
• collector가 제공하는 기능 :
  • stream 요소들을 List, Set, Map 자료형으로 변환
  • stream 요소들의 결합( joining )
  • stream 요소들의 통계( 최대, 최소, 평균값, .. )
  • stream 요소들의 그룹화 와 분할

[hgene0929]

Collectors

• collector가 제공하는 기능 중 미리 정의된 모든 구현은 Collectors 클래스에서 찾을 수 있음
• 이때, 가독성을 위한 static import 사용이 일반적

• Collectors.toMap()

  • 인자 : keyMapper 와 valueMapper 정의 필요
  • toMap 메서드는 중복을 자동으로 필터링하지 X → 키값이 중복될 경우 IllegalStateException
  • mergeFunction() : 동일한 키로 인해 충돌 발생시, 어떠한 value를 취할 것인지 결정할 때 사용
  • Supplier ****mapFactory : Collectors.toMap() 메서드를 통해 LinkedHashMap( 순서유지 )을 생성하고 싶은 경우 4st 인자로 사용 가능

  /* 
   * 아래의 코드에서 keyMapper, valueMapper( 키와 값을 생산하는 두 함수 인자 )를 통해 
   * Key-Value 형태로 매핑해줘야함 
   */
  Map<keyType, valueType> map = strings.stream()
                  .collect(Collectors.toMap(keyMapper, valueMapper));
  
  /* 
   * 예제1) List -> 요소의 길이를 key값으로 매핑한 Map 자료형으로 변환
   * keyMapper   : 각 요소.length()의 결과를 key값으로 사용
   * valueMapper : Function.identity() 메서드는 값이 실제 요소인 경우 사용
   * 결과 : {4=pear, 5=apple, 6=banana}
   */
  List<String> strings = Arrays.asList("apple", "banana", "pear");
  
  Map<Integer, String> map = strings.stream()
          .collect(Collectors.toMap(String::length, Function.identity()));
  
  System.out.println(map);
  
  /* 
   * 예제2) key값이 중복되는 경우 Collectors.toMap()
   * 결과 : java.lang.IllegalStateException: Duplicate key
   */
  List<String> strings = Arrays.asList("apple", "banana", "grape");
  
  Map<Integer, String> map = strings.stream()
          .collect(Collectors.toMap(String::length, Function.identity()));
  
  System.out.println(map);
  
  /* 
   * 예제3) Key의 중복 해결 : mergeFunction
   * 3rd 인자로 mergeFunction을 넣어서 충돌발생시 이를 해결하기 위한 방안 미리 제공
   * (oldVal, newVal) -> oldVal : 새로운값과 기존값 충돌시, 기존값을 유지
   * 결과 : {5=apple, 6=banana}
   */
  List<String> strings = Arrays.asList("apple", "banana", "grape");
  
  Map<Integer, String> map = strings.stream()
          .collect(Collectors.toMap(
                      String::length, 
                      Function.identity(), 
                      (oldVal, newVal) -> oldVal
          ));
  
  System.out.println(map);
  
  /* 
   * 예제4-1) LinkedHashMap 형태의 결과 반환 Supplier<M> mapFactory
   * 4st 인자로 Map 객체를 제공( 새롭게 생성한 emptyMap 제공 )
   * 결과 : {5=apple, 6=banana, 4=pear}
   */
  List<String> strings = Arrays.asList("apple", "banana", "pear", "grape");
  
  Map<Integer, String> map = strings.stream()
          .collect(Collectors.toMap(
                  String::length, 
                  Function.identity(), 
                  (oldVal, newVal) -> oldVal,
                  LinkedHashMap:: new
          ));
  
  System.out.println(map);
  
  /* 
   * 예제4-2) LinkedHashMap 형태의 결과 반환 Supplier<M> mapFactory
   * 4st 인자로 Map 객체를 제공( 이전에 생성한 notEmptyMap 제공 )
   * 결과 : {1004=서울 17반 북스터디, 5=apple, 6=banana, 4=pear}
   */
  List<String> strings = Arrays.asList("apple", "banana", "pear", "grape");
  LinkedHashMap<Integer, String> notEmptyMap = new LinkedHashMap<>();
  notEmptyMap.put(1004, "서울 17반 북스터디");
  
  Map<Integer, String> map = strings.stream()
          .collect(Collectors.toMap(
                  String::length, 
                  Function.identity(), 
                  (oldVal, newVal) -> oldVal,
                  () -> notEmptyMap
          ));
  
  System.out.println(map);

[hgene0929]

groupingBy() & partitioningBy()

• partitioningBy() :
  • stream 요소를 지정한 조건에 일치 or 불일치 하는 2 그룹으로 분할
  • 결과 반환 : Predicate(true, false)가 key, 각 기준에 맞게 분할된 요소List가 value인 Map 반환
• groupingBy() :
  • stream 요소를 특정한 기준으로 그룹화
  • 결과 반환 : Function(결과값)가 key, 각 기준에 맞게 분할된 요소List가 value인 Map 반환
• 일반적으로 stream을 2 개의 그룹으로 나눠야하는 경우 groupingBy() 보다 partitioningBy()가 더 빠름
  • Predicate가 조건의 참거짓여부만 연산하면 되니까 Function에 더 많은 기능을 수행할 수록 Predicate의 속도가 더 빠를 것

• Stream 요소를 그룹화하여 수집하기

  • groupingBy() vs toMap() : 특정 기준값을 key로 둘 다 key-value값을 가지는데 무슨 차이가 있을까?

    • 디폴트 :
      • groupingBy()는 value에 리스트가 기본( 그래서 사실상 2nd인자 생략하면 toList 자동 )
      • toMap()은 value에 단일요소가 기본
    • toMap을 통한 그룹화 방법 :

    /*
     * 1. valueMapper 인자에 리스트를 반환하는 메서드를 넣어라
     * 2. mergeFunction 인자에 중복키값 발생시, 대체가 아니라 누적하는 메서드를 넣어라
     * 결과 : {4=[pear], 5=[apple, grape], 6=[banana]}
     */
    public class Temp {
    
        public static void main(String[] args) {
    
            List<String> strings = Arrays.asList("apple", "banana", "grape", "pear");
    
            Map<Integer, List<String>> map = strings.stream()
                    .collect(Collectors.toMap(
                                String::length, 
                                Temp::stringToList, 
                                Temp::merge
                    ));
    
            System.out.println(map);
        }
    
        /* 새로운 key값을 가진 value인 경우, 리스트를 생성하고 담아서 반환 */
        static List<String> stringToList(String str) {
            List<String> strs = new ArrayList<>();
            strs.add(str);
            return strs;
        }
    
        /* 중복되는 key값을 가진 value인 경우, 기존의 리스트에 병합하여 반환 */
        static List<String> merge(List<String> oldVal, List<String> newVal) {
            oldVal.addAll(newVal);
            return oldVal;
        }
    }

    • toMap() 으로 그룹화할 때의 단점 (출처) :
      • 과도한 객체 생성 : 커스텀해서 만들어둔 stringToList() 메서드 내부에서는 새로운 key값을 가진 value가 나올때마다 ArrayList 객체 생성해야함 ⇒ 과도한 메모리 사용을 유발할 수 있음
      • 성능 저하 : 과도한 객체 생성과 계속되는 병합 연산 코드가 존재함 ⇒ 성능 저하의 원인이 될 수 있음