이펙티브 자바, 쉽게 정리하기 - item 46. 스트림에서는 부작용 없는 함수를 사용하라

이펙티브 자바, 쉽게 정리하기 - item 46. 스트림에서는 부작용 없는 함수를 사용하라

스트림의 핵심

• 스트림은 사용법을 아는 것만으로 충분하지 않다.
• 패러다임을 받아들여야 한다.
• 패러다임의 핵심은 계산을 일련의 변환으로 재구성하는 부분이다.
  • 변환 과정에 사용되는 함수는 순수함수여야 한다.

스트림을 이용한 코드의 진화 과정

단어 개수 세기 1: 사용법만 아는 단계

@Test
public void wordFreq1Test() {
    List<String> words = new ArrayList<>();
    words.add("stop");
    words.add("spot");
    words.add("trim");
    words.add("meet");
    words.add("ball");
    words.add("free");
    words.add("trim");
    words.add("meet");

    Map<String, Long> freq = new HashMap<>();

    words.stream().forEach(
            word -> freq.merge(word.toLowerCase(), 1L, Long::sum)
    );

    System.out.println("words = " + words);
    System.out.println("freq = " + freq);
}

• 스트림의 forEach() 메서드를 이용한 코드이다.
• 배열을 처리해야 한다면 스트림으로 처리하겠다는 생각에서 출발했을 것이다.
• 그런데, 일반적으로 Stream 루프에서 외부 상태를 변경할 것이라곤 쉽게 생각하지 못한다.
• 그리고, Stream 루프 내부에서 Side-Effect 가 있는 내용을 작성하면 여러가지 문제가 발생한다.

Stream 내부에서 사이드이펙트를 사용하면 발생하는 문제 (책에 없어서 추가)

• 가독성: Stream 을 사용한 순간 데이터의 변환과 평가가 이뤄질 것이라 기대하는데 그런 코드가 아니어서 읽기 어렵다.
• 재사용성: 외부 상태에 의존해버리기 때문에 쉽게 재사용이 불가능해진다.
• 테스트 가능성: Stream 은 일반 로직과 다른 흐름을 가진다. 병렬로도 실행될 수 있는 것이라 테스트하기도 어려워진다.
• 동시성: 멀티 스레드 프로그래밍에서 흔히 발생하는 공유 가변 상태와 관련된 문제를 피하기 어려워진다.

단어 개수 세기 1-1: 필요 없는 스트림 빼기

@Test
public void wordFreq1Test() {
    List<String> words = new ArrayList<>();
    words.add("stop");
    words.add("spot");
    words.add("trim");
    words.add("meet");
    words.add("ball");
    words.add("free");
    words.add("trim");
    words.add("meet");

    Map<String, Long> freq = new HashMap<>();

    for (String word : words) {
        freq.merge(word.toLowerCase(), 1L, Long::sum);
    }

    System.out.println("words = " + words);
    System.out.println("freq = " + freq);
}

• 이번엔 스트림을 사용하지 않았다.
• 스트림의 forEach 를 이용한 코드가 위의 코드보다 깔끔하고 명확하다고 장담할 수 없다.
• 오히려 자바 개발자의 대부분은 스트림에 익숙하지 않아 위 코드가 더 친숙할 것이다.
• 이전의 코드는 그저 억지로 forEach만 사용한 게 아닐까?

스트림의 forEach 코드는 println() 과 같은 메서드를 이용해 계산의 결과를 보고할 때는 유용하다.
그러나 계산 그 자체에는 오히려 두번째 코드처럼 일반적인 자바의 for 문을 활용하는 것이 더 깔끔한 경우도 있다.

단어 개수 세기 2: 종단 연산의 활용

@Test
public void wordFreq3Test() {
    List<String> words = new ArrayList<>();
    words.add("stop");
    words.add("spot");
    words.add("trim");
    words.add("meet");
    words.add("ball");
    words.add("free");
    words.add("trim");
    words.add("meet");

    Map<String, Long> freq = words.stream()
                                  .collect(groupingBy(String::toLowerCase, counting()));

    System.out.println("words = " + words);
    System.out.println("freq = " + freq);
}

• 이전보다 코드의 줄 자체가 매우 짧아지고, 영어만 안다면 뜻도 훨씬 명확해진다.
• 문자열을 toLowerCase() 로 변환하여 그룹핑하겠다는 의도가 보인다.
• 그룹핑된 key 에 대한 value 는 단어의 개수인 counting() 이 들어갈 것이다.
• groupingBy() 나 counting() 같은 메서드를 가독성 좋게 쓸 수 있는 이유는 Collectors 의 멤버를 정적 임포트했기 때문이다.

java.util.stream.Collectors 클래스를 잘 알아야 활용 가능하다.
스트림을 제대로 활용하려면 메서드와 인터페이스 등 패러다임을 꼭 보아야 한다.
계산의 결과를 만드는 메서드들은 toList(), toSet(), toCollection() 등이 있다.

단어 개수 세기 3: 가장 많이 사용되는 단어 2개 뽑아보기

@Test
public void wordFreq4Test() {
    List<String> words = new ArrayList<>();
    words.add("stop");
    words.add("spot");
    words.add("trim");
    words.add("meet");
    words.add("ball");
    words.add("free");
    words.add("triM");
    words.add("TriM");
    words.add("meet");

    Map<String, Long> freq = words.stream()
                                  .collect(groupingBy(String::toLowerCase, counting()));

    List<String> topTwo = freq.keySet()
                              .stream()
                              .sorted(comparing(freq::get).reversed())
                              .limit(2)
                              .collect(Collectors.toList());

    System.out.println("words = " + words);
    System.out.println("freq = " + freq);
    System.out.println("topTwo = " + topTwo);
}

Collectors API 학습하기

symbol별 연산자 기호 매핑하기: 인자 2개짜리 toMap()

enum Operation {
    PLUS("+", "plus", (x, y) -> x + y),
    MINUS("-", "minus", (x, y) -> x - y),
    TIMES("*", "times", (x, y) -> x * y),
    DIVIDE("/", "divide", (x, y) -> x / y);

    private final String symbol;
    private final String english;
    private final BinaryOperator<Double> op;

    Operation(String symbol, String english, BinaryOperator<Double> op) {
        this.english = english;
        this.symbol = symbol;
        this.op = op;
    }

    @Override
    public String toString() {
        return symbol;
    }

    public String toEnglish() { return english; }

    public double apply(double x, double y) {
        return op.apply(x, y);
    }
}

@Test
public void stringToEnumTest() {
    Map<String, Operation> operationMap = Stream.of(Operation.values())
                                                .collect(toMap(e -> e.english, e -> e));
    System.out.println("operationMap = " + operationMap);
}

결과

operationMap = {minus=-, times=*, divide=/, plus=+}

• english가 key가 되고, Operation의 심벌이 value가 되었다.

List<Album> 데이터 Map<String, Album>으로 merge()하기: 인자 3개짜리 toMap()

@Test
public void maxByTest() {
    Album album1 = new Album("jake", "제이크 1집", 100);
    Album album2 = new Album("jake", "제이크 2집", 250);
    Album album3 = new Album("jack", "잭 1집", 990);
    Album album4 = new Album("jack", "잭 2집", 140);

    List<Album> albums = new ArrayList<>();
    albums.add(album1);
    albums.add(album2);
    albums.add(album3);
    albums.add(album4);

    Map<String, Album> topHits = albums.stream()
            .collect(
                    toMap(
                            Album::artist, a -> a, BinaryOperator.maxBy(comparing(Album::sales))
                    )
            );

    System.out.println("topHits = " + topHits);
}

• 사용자 정의 타입 Album에서 sales가 가장 많은 것만 매핑하였다.
• 첫번째 인자: Key로 사용될 값을 매핑한다.
• 두번째 인자: Value으로 사용될 값을 매핑한다.
• 세번째 인자: 중복된 Key에 Value가 들어왔을 때, 들어갈 값의 로직(BinaryOperator)을 매핑한다.

실행 결과

topHits = {jake=Album{artist='jake', name='제이크 2집', sales=250}, jack=Album{artist='jack', name='잭 1집', sales=990}}

리스트 값을 분류하여 맵으로 만들기: 기본 groupingBy()

@Test
public void wordFreq5Test() {
    List<String> words = new ArrayList<>();
    words.add("stop");
    words.add("spot");
    words.add("trim");
    words.add("meet");
    words.add("ball");
    words.add("free");
    words.add("triM");
    words.add("TriM");
    words.add("meet");

    Map<String, List<String>> alphabetizedMap = words.stream()
                                                     .collect(groupingBy(this::alphabetize));
    System.out.println("alphabetizedMap = " + alphabetizedMap);
}

private String alphabetize(String s) {
    char[] a = s.toCharArray();
    Arrays.sort(a);
    return new String(a);
}

실행 결과

alphabetizedMap = {eefr=[free], MTir=[TriM], opst=[stop, spot], imrt=[trim], eemt=[meet, meet], Mirt=[triM], abll=[ball]}

• 자동으로 value에는 기존의 값이 들어가있다.
  • 오직 key만 alphabetize()가 적용된 형태이다.

groupingByConcurrent()는 ConcurrentHashMap 인스턴스를 만드는 유용한 함수이다.

기타 Collectors의 집계 메서드들

partitioningBy()

Map<Boolean, List<String>> partitioningByMap = words.stream()
                                                    .collect(partitioningBy((word) -> word.equals("stop")));
System.out.println("partitioningByMap = " + partitioningByMap);

• value 가 List 타입인 Map 을 반환한다.

실행 결과

partitioningByMap = {false=[spot, trim, meet, ball, free, triM, TriM, meet], true=[stop]}

숫자를 집계하는 다양한 메서드들

@Test
public void collectorsMethodTest() {
    Student jake = new Student("Jake", 15);
    Student jackson = new Student("Jackson", 55);
    Student joe = new Student("Joe", 85);
    Student amy = new Student("Amy", 21);
    Student roy = new Student("Roy", 33);

    List<Student> students = new ArrayList<>();
    students.add(jake);
    students.add(jackson);
    students.add(joe);
    students.add(amy);
    students.add(roy);

    int sumOfScore = students.stream()
                             .collect(summingInt(Student::score));
    double averageOfScore = students.stream()
                                    .collect(averagingInt(Student::score));
    IntSummaryStatistics intSummaryOfScore = students.stream()
                                                     .collect(summarizingInt((s) -> s.score));

    System.out.println("sumOfScore = " + sumOfScore);
    System.out.println("averageOfScore = " + averageOfScore);
    System.out.println("intSummaryOfScore = " + intSummaryOfScore);
}

실행 결과

sumOfScore = 209
averageOfScore = 41.8
intSummaryOfScore = IntSummaryStatistics{count=5, sum=209, min=15, average=41.800000, max=85}

• 다양한 집계 결과를 따로 구할 필요 없이 쉽게 구할 수 있는 도우미 메서드들이 있다.

문자열을 합쳐주는 유용한 메서드: joining()

@Test
public void joiningTest() {
    List<String> food = new ArrayList<>();
    food.add("피자");
    food.add("햄버거");
    food.add("치킨");

    String collect = food.stream().collect(joining(" 그리고 "));
    System.out.println("collect = " + collect);
}

실행 결과

collect = 피자 그리고 햄버거 그리고 치킨

문자열을 합쳐주는 유용한 메서드: joining() 인자 3개 버전

@Test
public void joiningTest() {
    List<String> food = new ArrayList<>();
    food.add("피자");
    food.add("햄버거");
    food.add("치킨");

    String collect = food.stream().collect(
            joining(", ", "맛있는 ", "이 좋아"));

    System.out.println("collect = " + collect);
}

실행 결과

collect = 맛있는 피자, 햄버거, 치킨이 좋아

• delimeter에 이어 prefix와 suffix까지 붙여줄 수 있다.

핵심 정리

• 스트림 파이프라인에는 부작용 없는 함수를 사용하자.
• forEach는 결과 보고에만 사용하며, 연산을 하지 말자.
• Collectors 내부 메서드로 다양한 집계를 할 수 있다.