🐹 chap5. 스트림 활용

5.1 필터링

스트림의 요소를 선택하는 방법에 대한 내용이다.

5.1.1 프레디케이트로 필터링

filter 메서드는 프레디케이트(boolean을 반환하는 함수)를 인수로 받아서 프레디케이트와 일치하는 모든 요소를 포함하는 스트림을 반환한다.

List<Dish> vegetarianMenu = menu.stream()
                                .filter(Dish::isVegetarian) // 채식 요리인지 확인하는 메서드 참조
                                .collect(toList());

5.1.2 고유 요소 필터링

스트림은 고유 요소로 이루어진 스트림을 반환하는 distinct 메서드도 지원한다(고유 여부는 스트림에서 만든 객체의 hashCode, equals로 결정된다).

List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
numbers.stream()
       .filter(i -> i % 2 == 0)
       .distinct()
       .forEach(System.out::println);

5.2 스트림 슬라이싱

스트림의 요소를 선택하거나 스킵하는 방법이다.

5.2.1 프레디케이트를 이용한 슬라이싱

자바 9는 스트림의 요소를 효과적으로 선택할 수 있도록 takeWhile, dropWhile 두 가지 새로운 매서드르 지원한다.

takeWhile 활용

요리 목록은 다음과 같다.

List<Dish> specialMenu = Arrays.asList(
    new Dish("seasonal fruit", true, 120, Dish.Type.OTHER),
    new Dish("prawns" false, 300, Dish.Type.FISH)
    new Dish("rice", true, 350, Dish.Type.OTHER),
    new Dish("chicken", false, 400, Dish.Type.MEAT),
    new Dish("french fries", true, 530, Dish.Type.OTHER));

320 칼로리 이하의 요리를 선택하기 위해서 어떻게 해야할까? 이전 filter에서 배운 내용은 아래와 같다.

List<Dish> filteredMenu
    = specialMenu.stream()
                 .filter(dish -> dish.getCalories() < 320)
                 .collect(toList());

요리 리스트가 이미 칼로리 순으로 정렬되어 있다는 사실에 주목하자. filter 연산을 이용하면 전체 스트림을 반복하면서 각 요소에 프레디케이트를 적용하게 된다.

따라서 이미 정렬되어 있다는 사실을 이용해 320 칼로리보다 크거나 같은 요리가 나왔을 때 반복 작업을 중단할 수 있다. 이는 큰 스트림에서는 상당한 차이가 있을 수 있다.

takeWhile 연산을 이용하면 무한 스트림을 포함한 모든 스트림에 프레디케이트를 적용해 스트림을 슬라이스할 수 있다.

List<Dish> slicedMenu1
    = specialMenu.stream()
                 .takeWhile(dish -> dish.getCalories() < 320)
                 .collect(toList());

dropWhile 활용

320 칼로리보다 큰 요소(나머지 요소)를 탐색하기 위해서는 dropWhile을 이용하면 된다.

List<Dish> slicedMenu2
    = specialMenu.stream()
                 .dropWhile(dish -> dish.getCalories() < 320)
                 .collect(toList());

dropWhile은 takeWhile과 정반대의 작업을 수행한다. dropWhile은 프레디케이트가 처음으로 거짓이 되는 지점까지 발견된 요소를 버린다. 프레디케이트가 거짓이 되면 그 지점에서 작업을 중단하고 남은 요소를 반환한다. dropWhile은 무한한 남은 요소를 가진 무한 스트림에서도 동작한다.

5.2.2 스트림 축소

limit

스트림은 주어진 값 이하의 크기를 갖는 새로운 스트림을 반환하는 limit(n) 메서드를 지원한다.

List<Dish> dishes = specialMenu.stream()
                               .filter(dish -> dish.getCalories() > 300)
                               .limit(3)
                               .collect(toList());

프레디케이트와 일치하는 처음 세 요소를 선택한 다음에 즉시 결과를 반환한다.

→ 모든 요소를 필터링 하지 않는다!

정렬되지 않은 스트림에도 limit을 사용할 수 있다. 소스가 정렬되어 있지 않았다면 limit의 결과도 정렬되지 않은 상태로 반환된다.

5.2.3 요소 건너뛰기

skip

스트림은 처음 n개 요소를 제외한 스트림을 반환하는 skip(n) 메서드를 지원한다. n개 이하의 요소를 포함하는 skip(n)을 호출하면 빈 스트림이 반환된다.

limit(n)과 skip(n)은 상호 보완적인 연산을 수행한다.

// 처음 두 요리는 건너뛴 다음 300칼로리 넘는 요리 반환
List<Dish> dishes = menu.stream()
                        .filter(d -> d.getCalories() > 300)
                        .skip(2)
                        .collect(toList());

• Quiz. 필터링

  스트림을 이용해서 처음 등장하는 두 고기 요리를 필터링하시오.

  • 정답

      List<Dish> meatDishes = menu.stream()
                                  .filter(d -> d.getType() == Dish.Type.MEAT)
                                  .limit(2)
                                  .collect(toList());
    

5.3 매핑

스트림의 특정 데이터를 선택하는 기능이다.

ex. 특정 객체에서 특정 데이터 선택

5.3.1 스트림의 각 요소에 함수 적용하기

map

스트림은 함수를 인수로 받는 map 메서드를 지원한다. 인수로 제공된 함수는 각 요소에 적용되며 함수를 적용한 결과가 새로운 요소로 매핑된다. (이 과정은 ‘기존의 값을 고친다’라는 개념보다 ‘새로운 버전을 만든다’라는 개념에 가까우므로 변환에 가까운 매핑이라는 단어를 사용한다.)

// Dish::getName을 map 메서드로 전달해 스트림의 요리명 추출
List<String> dishNames = menu.stream()
                             .map(Dish::getName)
                             .collect(toList());

getName은 문자열을 반환하므로 map 메서드의 출력 스트림은 Stream 형식을 갖는다.

이번엔 다른 예시를 보자.

// String::length를 map 메서드로 전달해 스트림의 길이를 추출
List<String> words = Arrays.asList("Modern", "Java", "In", "Action");
List<Integer> wordLengths = words.stream()
                                 .map(String::length)
                                 .collect(toList());

위 두 예시를 합쳐보면

// 요리명의 길이 추출
List<Integer> dishNameLengths = menu.stream()
                                    .map(Dish::getName)
                                    .map(String::length)
                                    .collect(toList());

이처럼 map 메서드를 연결해서 사용할 수 있다.

5.3.2 스트림의 평면화

리스트에서 고유 문자로 이루어진 리스트를 반환하려 한다. 예를 들어 [”Hello”, “World”] 리스트가 있다면 결과로 [”H”, “e”, “l”, “o”, “W”, “r”, “d”]를 포함하는 리스트가 반환되어야 한다.

리스트에 있는 각 단어를 문자로 매핑한 다음 distinct로 중복된 문자를 필터링해 쉽게 해결할 수 있을 것이라 생각할 것이다.

words.stream()
     .map(word -> word.split(""))
     .distinct()
     .collect(toList());

위 코드에서 map으로 전달한 람다는 각 단어의 String[] (문자열 배열)을 반환한다는 점이 문제다. 따라서 map 메소드가 반환한 스트림의 형식은 Stream<String[]>이다. 우리가 원하는 것은 문자열의 스트림을 표현할 Stream이다.

위 같은 문제를 flatMap이라는 메서드를 이용해서 해결할 수 있다.

map과 Arrays.stream 활용

우선 배열 스트림 대신 문자열 스트림이 필요하다. 문자열을 받아 스트림을 만드는 Arrays.stream() 메서드가 있다.

String[] arrayOfWords = {"Goodbye", "World"};
Stream<String> streamOfwords = Arrays.stream(arrayOfWords);

위 예제의 파이프라인에 Arrays.stream() 메서드를 적용해보자.

words.stream()
     .map(word -> word.split("")) // 각 단어를 개별 문자열 배열로 변환
     .map(Arrays::stream) // 각 배열을 별도의 스트림으로 생성
     .distinct()
     .collect(toList());

결국 스트림 리스트(엄밀히 따지면 List<Stream>)가 만들어지면서 문제가 해결되지 않았다. 문제를 해결하려면 **먼저 각 단어를 개별 문자열로 이루어진 배열로 만든 다음에 각 배열을 별도의 스트림으로 만들어야한다.**

flatMap 사용

flatMap을 사용하면 다음처럼 문제를 해결할 수 있다.

List<String> uniqueCharacters = 
    words.stream()
         .map(word -> word.split("")) // 각 단어를 개별 문자를 포함하는 배열로 변환
         .flatMap(Arrays::stream) // 생성된 스트림을 하나의 스트림으로 평면화
         .distinct()
         .collect(toList());

flatMap은 각 배열을 스트림이 아니라 스트림의 콘텐츠로 매핑한다. 즉, map(Arrays::stream)과 달리 flatMap은 하나의 평면화된 스트림을 반환한다.

flatMap 메서드는 스트림의 각 값을 다른 스트림으로 만든 다음에 모든 스트림을 하나의 스트림으로 연결하는 기능을 수행한다.

• Quiz. 매핑
  1. 숫자 리스트가 주어졌을 때 각 숫자의 제곱근으로 이루어진 리스트를 반환하시오. 예를 들어 [1, 2, 3, 4, 5]가 주어지면 [1, 4, 9, 16, 25]를 반환해야 한다.
     • 정답

      List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
      List<Integer> squares = numbers.stream()
                                     .map(n -> n * n)
                                     .collect(toList());
     

  2. 두 개의 숫자 리스트가 있을 때 모든 숫자 쌍의 리스트를 반환하시오. 예를 들어 두 개의 리스트 [1, 2, 3]과 [3, 4]가 주어지면 [(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]를 반환해야 한다.
     • 정답

      List<Integer> numbers1 = Arrays.asList(1, 2, 3);
      List<Integer> numbers2 = Arrays.asList(3, 4);
      List<int[]> pairs 
          = numbers1.stream()
                    .flatMap(i -> numbers2.stream()
                                          .map(j -> new int[]{i, j})
                    )
                    .collect(toList());
     

     두 개의 map을 이용해서 두 리스트를 반복한 다음에 숫자 쌍을 만들 수 있다. 하지만 결과로 Stream<Stream<Integer[]»>가 반환된다. 따라서 결과를 Stream<Integer[]>로 평면화한 스트림이 필요하다. 바로 flatMap을 사용해야 한다.

  3. 이전 예제에서 합이 3으로 나누어떨어지는 쌍만 반환하려면 어떻게 해야 할까? 예를 들어 (2, 4), (3, 3)을 반환해야 한다.

     • 정답

         List<Integer> numbers1 = Arrays.asList(1, 2, 3);
         List<Integer> numbers2 = Arrays.asList(3, 4);
         List<int[]> pairs 
             = numbers1.stream()
                       .flatMap(i -> numbers2.stream()
                                             .filter(j -> (i + j) % 3 == 0)
                                             .map(j -> new int[]{i, j})
                       )
                       .collect(toList());
       

       filter를 프레디케이트와 함께 사용하면 스트림의 요소를 필터링할 수 있다. flatMap을 실행하면 숫자 쌍을 포함하는 int[] 스트림이 반환되므로 프레디케이트를 이용해서 숫자 쌍의 합이 3으로 나누어떨어지는지 확인할 수 있다.

5.4 검색과 매칭

특정 속성이 데이터 집합에 있는지 여부를 검색하는 데이터 처리

5.4.1 프레디케이트가 적어도 한 요소와 일치하는지 확인

anyMatch

프레디케이트가 주어진 스트림에서 적어도 한 요소와 일치하는지 확인할 때 사용한다.

// menu에 채식요리가 있는지 확인하는 예제
if(menu.stream().anyMatch(Dish::isVegetarian)) {
    System.out.println("The menu is (somewhat) vegetarian friendly!!");
}

anyMatch는 boolean을 반환하므로 최종 연산이다.

5.4.2 프레디케이트가 모든 요소와 일치하는지 검사

allMatch

anyMatch와 달리 스트림의 모든 요소가 주어진 프레디케이트와 일치하는지 검사한다.

// 건강식 찾기(1000칼로리 이하)
boolean isHealthy = menu.stream()
                        .allMatch(dish -> dish.getCalories() < 1000);

noneMatch

allMatch와 반대 연산을 수행한다. 즉, 주어진 프레디케이트와 일치하는 요소가 없는지 확인한다.

boolean isHealthy = menu.stream()
                        .noneMatch(d -> d.getCalories >= 1000);

anyMatch, allMatch, noneMatch는 스트림 쇼트서킷 기법, 즉 자바의 &&,

와 같은 연산을 활용한다.

(모든 스트림의 요소를 처리하지 않고도 결과 반환)

5.4.3 요소 검색

findAny

현재 스트림에서 임의의 요소를 반환한다. findAny 메서드는 다른 스트림 연산과 연결해서 사용할 수 있다.

// 채식 요리 선택
Optional<Dish> dish =
    menu.stream()
        .filter(Dish::isVegetarian)
        .findAny();

스트림 파이프라인은 내부적으로 단일 과정으로 실행할 수 있도록 최적화된다. 즉, 쇼트서킷을 이용해서 결과를 찾는 즉시 실행을 종료한다.

Optional이란?

Optional 클래서(java.util.Optional>는 값의 존재나 존재 여부를 표현하는 컨테이너 클래스다. 이전 예제에서 findAny는 아무 요소도 반환하지 않을 수 있다. null은 쉽게 에러를 일으킬 수 있으므로 자바 8에선 Optional를 제공한다.

Optional은 값이 존재하는지 확인하고 값이 없을 때 어떻게 처리할지 강제하는 기능을 제공한다.

• isPresent()는 Optional이 값을 포함하면 참(true)을 반환하고, 값을 포함하지 않으면 거짓(false)을 반환한다.
• ifPresent(Consumer block)은 값이 있으면 주어진 블록을 실행한다. Consumer 함수형 인터페이스에는 T 형식의 인수를 받으며 void를 반환하는 람다를 전달할 수 있다.
• T get()은 값이 존재하면 값을 반환하고, 값이 없으면 NoSuchElementException을 일으킨다.
• T orElse (T other)는 값이 있으면 값을 반환하고, 값이 없으면 기본값을 반환한다.

menu.stream()
    .filter(Dish::isVegetarian)
    .findAny() // Optional<Dish> 반환
    .ifPresent(dish -> System.out.println(dish.getName()); // 값이 있으면 출력, 없으면 아무일도 일어나지 않는다. 

위 코드에서 findAny로 Optional가 반환되기 때문에 요리명이 null인지 검사할 필요가 없다.

5.4.4 첫 번째 요소 쓰기

리스트 또는 정렬된 연속 데이터로부터 생성된 스트림처럼 일부 스트림에는 논리적인 아이템 순서가 정해져 있을 수 있다. 이때 스트림에서 첫 번째 요소를 찾아보자.

// 3으로 떨어지는 첫 번째 제곱값을 반환
List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> firstSquareDivisibleByTree = 
    someNumbers.stream()
               .map(n -> n * n)
               .filter(n -> n % 3 == 0)
               .findFirst();

5.5 리듀싱(폴드)

모든 스트림 요소를 처리해서 값으로 도출하는 것

5.5.1 요소의 합

// 리스트의 숫자 요소의 합
int sum = 0;
for (int x : numbers) {
    sum += x;
}

numbers의 각 요소는 결과에 반복적으로 더해진다. 리스트에서 하나의 숫자가 남을 때까지 reduce 과정을 반복한다. 코드에는 파라미터 2개를 사용했다.

• sum 변수의 초깃값 0
• 리스트이 모든 요소를 조합하는 연산(+)

reduce를 이용하면 애플리케이션의 반복된 패턴을 추상화할 수 있다. reduce를 이용해서 다음처럼 스트림의 모든 요소를 더할 수 있다.

int sum = numbers.stream().reduce(0, (a, b) -> a + b);

reduce는 2개의 인수를 갖는다.

• 초깃값 0
• 두 요소를 조합해서 새로운 값을 만드는 BinaryOperator. 예제에서는 람다 표현식 (a, b) → (a + b)를 사용했다.

스트림이 하나의 값으로 줄어들 때까지 람다는 각 요소를 반복해서 조합한다.

메서드 참조를 이용해서 이 코드를 좀 더 간결하게 만들 수 있다. 자바 8에서는 Integer 클래스에서 두 숫자를 더하는 정적 sum 메서드를 제공한다. 따라서 직접 람다 코드를 구현할 필요가 없다.

int sum = numbers.stream().reduce(0, Integer::sum);

초깃값 없음

초깃값을 받지 않도록 오버로드된 reduce도 있다. 그러나 이 reduce는 Optional 객체를 반환한다.

Optional<Integer> sum = numbers.stream().reduce((a, b) -> (a + b));

위의 경우 스트림에 아무 요소도 없는 상황에서 초깃값이 없으므로 reduce는 합계를 반환할 수 없다. 따라서 합계가 없음을 가리킬 수 있도록 Optional 객체로 감싼 결과를 반환한다.

5.5.2 최댓값과 최솟값

최댓값과 최솟값을 찾을 때도 reduce를 활용할 수 있다. reduce를 이용해서 스트림에서 최댓값과 최솟값을 찾는 방법을 살펴보자. reduce는 두 인수를 받는다.

• 초깃값
• 스트림의 두 요소를 합쳐서 하나의 값으로 만드는 데 사용할 람다

// 최댓값
Optional<Integer> max = numbers.stream().reduce(Integer::max);

// 최솟값
Optional<Integer> min = numbers.stream().reduce(Integer::min);

Integer::min 대신 람다 표현식 (x, y) → x < y ? x : y를 사용해도 무방하지만 메서드 참조 표현이 더 읽기 쉽다.

• Quiz. 리듀스

  map과 reduce 매서드를 이용해서 스트림의 요리 개수를 계산하시오.

  • 정답

    스트림의 각 요소를 1로 매핑한 다음에 reduce로 이들의 합계를 계산하는 방식으로 문제를 해결할 수 있다. 즉, 스트림에 저장된 숫자를 차례로 한다.

      int count = 
          menu.stream()
              .map(d -> 1)
              .reduce(0, (a, b) -> a + b);
    

    map과 reduce를 연결하는 기법을 맵 리듀스 패턴이라 하며, 쉽게 병렬화하는 특징 덕분에 구글이 웹 검색에 적용하면서 유명해졌다.

      long count = menu.stream().count();
    

    이것도 가능하다.

reduce 메서드의 장점과 병렬화

reduce를 이용하면 내부 반복이 추상화되면서 내부 구현에서 병렬로 reduce를 실행할 수 있게 된다. 반복적인 합계에서는 sum 변수를 공유해야 하므로 쉽게 병렬화하기 어렵다.

코드를 병렬로 만들기 위해서는 stream()을 parallelStream()으로 바꾸면 된다.

int sum = numbers.parallelStream().reduce(0, Integer::sum);

위처럼 병렬로 실행하려면 조건이 있다. reduce에 넘겨준 람다의 상태(인스턴스 변수 같은)가 바뀌지 말아야 하며, 연산이 어떤 순서로 실행되더라도 결과가 바뀌지 않는 구조여야 한다.

스트림 연산 : 상태 없음과 상태 있음

• 내부 상태를 갖지 않는 연산
  • map, filter 등
  • 입력 스트림에서 각 요소를 받아 0 또는 결과를 출력 스트림으로 보낸다.
• 내부 상태를 갖는 연산
  • reduce, sum, max 등
  • 결과를 누적할 내부 상태가 필요 → 스트림에서 처리하는 요소 수와 관계없이 내부 상태의 크기는 한정되어 있다.
  • sorted, distinct 등은 filter나 map처럼 스트림을 입력으로 받는다.

  • 스트림의 요소를 정렬하거나 중복을 제거하려면 과거의 이력을 알고 있어야 한다.

    (ex. 어떤요소를 출력 스트림으로 추가하려면 모든 요소가 버퍼에 추가되어 있어야 한다.)

5.6 실전 연습

트랜잭션(거래)을 실행하는 거래자 예제를 살펴보자. 우리의 관리자가 여덟 가지 질문의 답을 찾으라고 요청했다.

1. 2011년에 일어난 모든 트랜잭션을 찾아 값을 오름차순으로 정리하시오.
2. 거래자가 근무하는 모든 도시를 중복 없이 나열하시오.
3. 케임브리지에서 근무하는 모든 거래자를 찾아서 이름순으로 정렬하시오.
4. 모든 거래자의 이름을 알파벳순으로 정렬해서 반환하시오.
5. 밀라노에 거래자가 있는가?
6. 케임브리지에 거주하는 거래자의 모든 트랜잭션값을 출력하시오.
7. 전체 트랜잭션 중 최댓값은 얼마인가?
8. 전체 트랜잭션 중 최솟값은 얼마인가?

5.6.1 거래자와 트랜잭션

거래자 리스트와 트랜잭션 리스트이다.

Trader raoul = new Trader("Raoul", "Cambridge");
Trader mario = new Trader("Mario", "Milan");
Trader alan = new Trader("Alan", "Cambridge");
Trader brian = new Trader("Brian", "Cambridge");

List<Transaction> transactions = Arrays.asList(
    new Transaction(brian, 2011, 300),
    new Transaction(raoul, 2012, 1000),
    new Transaction(raoul, 2011, 400),
    new Transaction(mario, 2012, 710),
    new Transaction(mario, 2012, 700),
    new Transaction(alan, 2012, 950)
);

다음은 Trader와 Transaction의 클래스 정의다.

public class Trader {

    private final String name;
    private final String city;

    public Trader(String n, String c) {
        this.name = n;
        this.city = c;
    }

    public String getName() {
        return this.name;
    }

    public String getCity() {
        return this.city;
    }

    public String toString() {
        return "Trader:" + this.name + " in " + this.city;
    }
}

public class Transaction {
	
    private final Trader trader;
    private final int year;
    private final int value;

    public Transaction(Trader trader, int year, int value) {
        this.trader = trader;
        this.year = year;
        this.value = value;
    }

    public Trader getTrader() {
        return this.trader;
    }

    public int getYear() {
        return this.year;
    }

    public int getValue() {
        return this.value;
    }

    public String toString() {
        return "{" + this.trader + ", " + 
            "year: " + this.year + ", " +
            "value: " + this.value + "}";
    }
}

정답

1. 2011년에 일어난 모든 트랜잭션을 찾아 값을 오름차순으로 정리하시오.

    List<Transaction> tr2011 = 
        transactions.stream()
                    .filter(transaction -> transaction.getYear() == 2011)
                    .sorted(comparing(Transaction::getValue)) // 트랜잭션 값으로 정렬
                    .collect(toList());
   

2. 거래자가 근무하는 모든 도시를 중복 없이 나열하시오.

    List<String> cities =
        transactions.stream()
                    .map(transaction -> transaction.getTrader().getCity())
                    .distinct() // 고유 도시만 선택
                    .collect(toList());
   

   distinct() 대신에 스트림을 집합으로 변환하는 toSet()을 사용할 수 있다.

    Set<String> cities =
        transactions.stream()
                    .map(transaction -> transaction.getTrader().getCity())
                    .collect(toSet());
   

3. 케임브리지에서 근무하는 모든 거래자를 찾아서 이름순으로 정렬하시오.

    List<Trader> traders = 
        transactions.stream()
                    .map(Transaction::getTrader) // 트랜잭션의 모든 거래자 추출
                    .filter(trader -> trader.getCity()**.equals("Cambridge")**)
                    .distinct() // 중복이 없도록 확인
                    .sorted(comparing(Trader::getName))
                    .collect(toList());
   

4. 모든 거래자의 이름을 알파벳순으로 정렬해서 반환하시오.

    String traderStr =
        transactions.stream()
                    .map(transaction -> transaction.getTrader().getName())
                    .distinct() 
                    .sorted() 
                    .reduce("", (n1, n2) -> n1 + n2); // 이름을 알파벳 순으로 정렬
   

   위 코드는 모든 문자열을 반복적으로 연결해서 새로운 문자열 객체를 만든다. 따라서 효율성이 부족하다. joining()을 이용해서 더 효율적으로 문제를 해결할 수 있다.(joining은 내부적으로 StringBuilder를 이용한다.)

    String traderStr =
        transactions.stream()
                    .map(transaction -> transaction.getTrader().getName())
                    .distinct()
                    .sorted()
                    .collect(joining());
   

5. 밀라노에 거래자가 있는가?

    boolean isTraderInMilan =
        transactions.stream()
                    .anyMatch(transaction -> transaction.getTrader()
                                                        .getCity()
                                                        .equals("Milan"));
    // anyMatch에 프레디케이트를 전달해서 밀라노에 거래자가 있는지 확인 
   

6. 케임브리지에 거주하는 거래자의 모든 트랜잭션값을 출력하시오.

    transactions.stream()
                .filter(t -> t.getTrader().getCity().equals("Cambridge"))
                .forEach(t -> System.out.println(t.getValue()));
   

7. 전체 트랜잭션 중 최댓값은 얼마인가?

    Optional<Integer> max_value = 
        transactions.stream()
                    .map(Transaction::getValue)
                    .reduce(Integer::max);
   

8. 전체 트랜잭션 중 최솟값은 얼마인가?

    Optional<Integer> min_value =
        transactions.stream()
                    .map(Transaction::getValue)
                    .reduce(Integer::min);
   

   더 쉬운 방법도 있다.

    Optional<Transaction> smallestTransaction =
        transactions.stream()
                    .min(comparing(Transaction::getValue));
   

   스트림은 최댓값이나 최솟값을 계산하는 데 사용할 키를 지정하는 Comparator를 인수로 받는 min과 max 메서드를 제공한다.

5.7 숫자형 스트림

// 메뉴의 칼로리 합계 계산
int calories = menu.stream()
                   .map(Dish::getCalories)
                   .reduce(0, Integer::sum);

이 코드에는 박싱 비용이 숨어있다. 내부적으로 합계를 계산하기 전에 Integer를 기본형으로 언박싱해야 한다.

// !!불가능한 코드
int calories = menu.stream()
                   .map(Dish::getCalories)
                   .sum();

위 코드처럼 sum 메서드를 직접 호출할 수 없다. map 메서드가 Stream를 생성하기 때문이다. 스트림의 요소 형식은 Integer지만 인터페이스에는 sum 메서드가 없다.

다행히도 스트림은 스트림 API 숫자 스트림을 효율적으로 처리할 수 있도록 기본형 특화 스트림을 제공한다.

5.7.1 기본형 특화 스트림

자바 8에서는 세 가지 기본형 특화 스트림을 제공한다.

• int 요소에 특화된 IntStream
• double 요소에 특화된 DoubleStream
• long 요소에 특화된 LongStream

각각의 인터페이스는 숫자 스트림의 합계를 계산하는 sum, 최댓값 요소를 검색하는 max 같이 자주 사용하는 숫자 관련 리듀싱 연산 수행 메서드를 제공한다.

특화 스트림은 오직 박싱 과정에서 일어나는 효율성과 관련 있으며 스트림에 추가 기능을 제공하지 않는다.

숫자 스트림으로 매핑

스트림을 특화 스트림으로 변환할 때는 mapToInt, mapToDouble, mapToLong 세 가지 메서드를 가장 많이 사용한다. 이들 메서드는 map과 정확히 같은 기능을 수행하지만, Stream 대신 특화된 스트림을 반환한다.

int calories = menu.stream()                    // Stream<Dish> 반환
                   .mapToInt(Dish::getCalories) // IntStream 반환
                   .sum();

mapToInt 메서드는 각 요리에서 모든 칼로리(Integer 형식)를 추출한 다음에 IntStream을(**Stream 아님**) 반환한다. 따라서 **IntStream 인터페이스에서 제공하는 sum 메서드**를 이용해서 칼로리 합계를 계산할 수 있다.

스트림이 비어있으면 sum은 기본값 0을 반환한다.

IntStream은 max, min, average 등 다양한 유틸리티 메서드도 지원한다.

객체 스트림으로 복원하기(boxed)

숫자 스트림 → 특화되지 않은 스트림

ex) IntStream은 기본형의 정수만 만들 수 있다.

// boxed 메서드를 통해 특화 스트림을 일반 스트림으로 변환
IntStream intStream = menu.stream().mapToInt(Dish::getCalories); // 스트림을 숫자 스트림으로 변환
Stream<Integer> stream = intStream.boxed(); // 숫자 스트림을 스트림으로 변환

기본값 : OptionalInt

IntStream에서는 최댓값을 찾을 때 0이라는 기본값이 있으면 잘못된 결과가 도출될 수 있다.

‘스트림에 요소가 없는 상황’과 ‘실제 최댓값이 0인 상황을 어떻게 구별할 수 있을까? Optional을 사용한다.

Optional을 Integer, String 등의 참조 형식으로 파라미터화할 수 있다. 또한 OptionalInt, OptionalDouble, OptionalLong 세 가지 기본형 특화 스트림 버전도 제공한다.

// OptionalInt를 이용해서 IntStream의 최댓값 요소를 찾을 수 있다.
**OptionalInt maxCalories** = menu.stream()
                                  .mapToInt(Dish::getCalories)
                                  .max();

이제 OptionalInt를 이용해서 최댓값이 없는 상황에 사용할 기본값을 명시적으로 정의할 수 있다.

int max = maxCalories.orElse(1); // 값이 없을 때 기본 최댓값을 명시적으로 설정 

5.7.2 숫자 범위

자바 8의 IntStream과 LongStream에서는 range와 rangeClosed라는 두 가지 정적 메서드를 제공한다. 두 메서드 모두 첫 번째 인수로 시작값을, 두 번째 인수로 종료값을 갖는다. range 메서드는 시작값과 종료값이 결과에 포함되지 않는 반면 rangeClosed는 시작값과 종료값이 결과에 포함된다는 점이 다르다.

IntStream evenNumbers = IntStream.rangeClosed(1, 100) // [1, 100] 범위
		                 .filter(n -> n % 2 == 0); // 짝수 스트림
System.out.println(evenNumbers.count());

위 코드에서 filter를 호출해도 실제로는 아무 계산도 이루어지지 않는다(중간 연산이고 최종 연산인 count가 실행될 때 진행됨!).

5.7.3 숫자 스트림 활용 : 피타고라스 수

세 수 표현하기

피타고라스 수 스트림을 만들기 위해 우선 세 수를 정의해야 한다. 세 요소를 갖는 int 배열을 사용하는 것이 좋을 것 같다. 예를들어 (3, 4, 5)를 new int[]{3, 4, 5}로 표현할 수 있다.

좋은 필터링 조합

세 수 중 a, b 두 수만 주어졌다고 가정했을 때, 두 수가 피타고라스 수의 일부가 될 수 있는지 확인할 수 있는 방법이 있을까?

a * a + b * b의 제곱근이 정수인지 확인할 수 있다.

Math.sqrt(a*a + b*b) % 1 == 0

이때 x가 부동 소숫점 수라면 x % 1.0이라는 자바 코드로 소숫점 이하 부분을 얻을 수 있다.

이것을 filter에 다음처럼 활용할 수 있다.

filter(b -> Math.sqrt(a*a + b*b) % 1 == 0)

위 코드에서 a라는 값이 주어지고 b는 스트림으로 제공된다고 가정할 때 filter로 a와 함께 피타고라스 수를 구성하는 모든 b를 필터링할 수 있다.

집합 생성

필터를 이용하여 좋은 조합을 갖는 a, b를 선택할 수 있게 되었다. 이제 마지막 세 번째 수를 찾아야 한다. 다음처럼 map을 이용해서 각 요소를 피타고라스 수로 변환할 수 있다.

stream.filter(b -> Math.sqrt(a*a + b*b) % 1 == 0)
      .map(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)});

b값 생성

이제 b값을 생성해야 한다. Stream.rangeClosed로 주어진 범위의 수를 만들 수 있음을 배웠다.

IntStream.rangeClosed(1, 100)
         .filter(b -> Math.sqrt(a*a + b*b) % 1 == 0)
         .boxed()
         .map(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)});

filter 연산 다음에 rangeClosed가 반환한 IntStream을 boxed를 이용해서 Stream로 복원했다.

개체값 스트림을 반환하는 IntStream의 mapToObj 메서드를 이용해서 이 코드를 재구현할 수 있다.

IntStream.rangeClosed(1, 100)
         .filter(b -> Math.sqrt(a*a + b*b) % 1 == 0)
         .mapToObj(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)});

a값 생성

마지막으로 a값을 생성하는 코드를 추가한다. b와 비슷한 방법으로 a값을 생성할 수 있다.

Stream<int[]> pythagoreanTriples =
    IntStream.rangeClosed(1, 100).boxed()
             .flatMap(a ->
                IntStream.rangeClosed(a, 100)
                         .filter(b -> Math.sqrt(a*a + b*b) % 1 == 0)
                         .mapToObj(b -> new int[]{a, b, (int)Math.sqrt(a*a+b*b)})
             );

위 코드에서 스트림 a의 값을 매핑하면 스트림의 스트림이 만들어질 것이다. 따라서 flatMap 메서드가 생성된 각각의 스트림을 하나의 평준화된 스트림으로 만들어준다. 결과적으로 세 수로 이루어진 스트림을 얻을 수 있다.

또한 b의 범위가 1이 아닌 a부터 시작함음 중복을 막기 위함이다.

코드 실행

limit을 사용하여 얼마나 많은 세 수를 포함하는 스트림을 만들 것인지 결정하면 된다.

pythagoreamTriples.limit(5)
                  .forEach(t -> 
                       System.out.println(t[0] + ", " + t[1] + ", " + t[2]));

개선할 점?

현재 코드에서는 제곱근을 두 번 계산한다. 따라서 (aa, bb, aa+bb) 형식을 만족하는 세 수를 만든 다음에 우리가 원하는 조건에 맞는 결과만 필터링하는 것이 더 최적화된 방법이다.

Stream<double[]> pythagoreanTriples2 =
	IntStream.rangeClosed(1, 100).boxed()
                 .flatMap(a -> IntStream.rangeClosed(a, 100))
                 .mapToObj(
                    b -> new double[]{a, b, Math.sqrt(a*a + b*b)}) // 만들어진 세 수
                 .filter(t -> t[2] % 1 == 0); // 세 수의 세 번째 요소는 반드시 정수여야 한다.

5.8 스트림 만들기

일련의 값, 배열, 파일, 함수를 이용한 무한 스트림 만들기 등 다양한 방식으로 스트림을 만드는 방법

5.8.1 값으로 스트림 만들기

Stream.of

임의의 수를 인수로 받는 정적 메서드 Stream.of를 이용해서 스트림을 만들 수 있다.

// 문자열 스트림 만들기
Stream<String> stream = Stream.of("Modern ", "Java ", "In ", "Action");
// 스트림의 모든 문자열을 대문자로 변환한 후 문자열을 하나씩 출력
stream.map(String::toUpperCase).forEach(System.out::println);

다음처럼 empty 메서드를 이용해서 스트림을 비울 수 있다.

Stream<String> emptyStream = Stream.empty();

다음처럼 empty 메서드를 이용해서 스트림을 비울 수 있다.

5.8.2 null이 될 수 있는 객체로 스트림 만들기

자바 9에서는 null이 될 수 있는 개체를 스트림으로 만들 수 있는 새로운 메소드가 추가되었다.

Stream.ofNullable

예를 들어 System.getProperty는 제공된 키에 대응하는 속성이 없으면 null을 반환한다. 이런 메소드를 스트림에 활용하려면 다음처럼 null을 명시적으로 확인해야 했다.

String homeValue = System.getProperty("home");
Stream<String> homeValueStream
	= homeValue == null ? Stream.empty() : Stream.of(value);

Stream.ofNullable을 이용해 다음처럼 코드를 구현할 수 있다.

Stream<String> homeValueStream
	= Stream.ofNullable(System.getProperty("home"));

null이 될 수 있는 객체를 포함하는 스트림값을 flatMap과 함께 사용하는 상황에서는 이 패턴을 더 유용하게 사용할 수 있다.

Stream<String> values =
    Stream.of("config", "home", "user")
          .flatMap(key -> Stream.ofNullable(System.getProperty(key)));

5.8.3 배열로 스트림 만들기

Arrays.stream

배열을 인수로 받는 정적 메서드 Arrays.stream을 이용해서 스트림을 만들 수 있다. 예를 들어 다음처럼 기본형 int로 이루어진 배열을 IntStream으로 변환할 수 있다.

int[] numbers = {2, 3, 5, 7, 11, 13};
int sum = Arrays.stream(numbers).sum(); // 합계는 41

5.8.4 파일로 스트림 만들기

파일을 처리하는 등의 I/O 연산에 사용하는 자바의 NIO API(비블록 I/O)도 스트림 API를 활용할 수 있도록 업데이트되었다. java.nio.file.Files의 많은 정적 메서드가 스트림을 반환한다.

예를 들어 Files.lines는 주어진 파일의 행 스트림을 문자열로 반환한다. 지금까지 배운 스트림 연산을 활용하면 다음 코드처럼 파일에서 고유한 단어 수를 찾는 프로그램을 만들 수 있다.

long uniqueWords = 0;
try(Stream<String> lines = 
	Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) 
{
    uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" "))) // 고유 단어수 계산
                                              .distinct() // 중복 제거
                                              .count();   // 단어 스트림 생성
} catch(IOException e) {
	// 파일을 열다가 예외가 발생하면 처리한다.
}

Files.lines로 파일의 각 행 요소를 반환하는 스트림을 얻을 수 있다. 스트림의 소스가 I/O 자원이므로 이 메소드를 try/catch 블록으로 감쌌고 메모리 누수를 막으려면 자원을 닫아야 한다.

기존에는 finally 블록에서 자원을 닫았다. Stream 인터페이스는 AutoCloseable 인터페이스를 구현한다. 따라서 try 블록 내의 자원은 자동으로 관리된다.

5.8.5 함수로 무한 스트림 만들기

스트림 API는 함수에서 스트림을 만들 수 있는 두 정적 메서드 Stream.iterate와 Stream.generate를 제공한다. 두 연산을 이용해서 무한 스트림, 즉 크기가 고정되지 않은 스트림을 만들 수 있다.

iterate와 generate에서 만든 스트림은 요청할 때마다 주어진 함수를 이용해서 값을 만들기 때문에 무제한으로 값을 계산할 수 있다. 무한한 값을 출력하지 않도록 보통 limit(n) 함수를 함께 사용한다.

iterate 메서드

Stream.iterate(0, n -> n + 2)
      .limit(10)
      .forEach(System.out::println);

• (초깃값 0, 람다) 인수

2씩 커지는 연산을 진행하고 요청할 때마다 값을 생산할 수 있으며 끝이 없으므로 무한 스트림을 만든다. → 언바운드 스트림

일반적으로 연속된 일련의 값을 만들 때 iterate를 사용한다.

• Quiz. 피보나치수열 집합

  피보나치수열은 유명한 고전 프로그래밍 문제다. 피보나치수열은 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 … 같은 식으로 구성된다. 수열은 0, 1로 시작하며 이후의 숫자는 이전 두 숫자를 더한 값이다. 피보나치수열의 집합도 비슷한 형태로 구성된다. 즉, (0, 1), (1, 1), (1, 2), (2, 3), (3, 5), (5, 8), (8, 13), (13, 21)… 처럼 연속적인 숫자로 이루어진다.

  우리가 해야할 일은 iterate 메서드를 이용해서 피보나치수열의 집합을 20개 만드는 것이다.

  우선 UnaryOperator를 인수로 받는 iterate 메서드를 이용해서 (0, 1) 같은 집합을 만들어야 한다. 우선 두 요소를 포함하는 배열로 대충 집합을 만들어 볼 수 있다. 즉, new int[]{0, 1}로 피보나치수열 집합 (0, 1)을 표현할 수 있다. 이를 iterate 메서드의 초깃값으로 사용한다.

    Stream.iterate(new int[]{0, 1}, ???)
          .limit(20)
          .forEach(t -> System.out.println("(" + t[0] + "," + t[1] + ")"));
  

  위 코드에서 ???로 표시된 부분을 해결해야 한다. iterate는 ???자리에 주어지는 람다를 연속적으로 적용하는 함수라는 사실을 기억하며 퀴즈를 풀어보자.

  • 정답

      Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0]+t[1]})
            .limit(20)
            .forEach(t -> System.out.println("(" + t[0] + "," + t[1] + ")"));
    

자바 9의 iterate 메소드는 프레디케이트를 지원한다.

// 0에서 시작해서 100보다 크면 숫자 생성 중단
IntStream.iterate(0, n -> n < 100, n -> n + 4)
	.forEach(System.out::println)

iterate 메소드는 두 번째 인수로 프레디케이트를 받아 언제까지 작업을 수행할 것인지의 기준으로 사용한다. filter 동작으로도 같은 결과를 얻을 수 있을 것이라 생각했을 수도 있을 것이다.

IntStream.iterate(0, n -> n + 4)
         .filter(n -> n < 100)
         .forEach(System.out::println);

안타깝게도 이와 같은 방법으로는 같은 결과를 얻을 수 없다. 실제로 위 코드는 종료되지 않는다. filter 메소드는 언제 이 작업을 중단해야 하는지를 알 수 없기 때문이다. 스트림 쇼트서킷을 지원하는 takeWhile을 이용하는 것이 해법이다.

IntStream.iterate(0, n -> n + 4)
         .takeWhile(n -> n < 100)
         .forEach(System.out::println);

generate 메서드

iterate와 비슷하게 generate도 요구할 때 값을 계산하는 무한 스트림을 만들 수 있다. 하지만 iterate와 달리 generate는 생산된 각 값을 연속적으로 계산하지 않는다. generate는 Supplier를 인수로 받아서 새로운 값을 생산한다.

Stream.generate(Math::random)
      .limit(5)
      .forEach(System.out::println);

이 코드는 0과 1 사이에서 임의의 더블 숫자 다섯 개를 만든다. 다음은 실행 결과다.

0.9410810294106129
0.6586270755634592
0.9592859117266873
0.13743396659487006
0.3942776037651241

Math.random은 임의의 새로운 값을 생성하는 정적 메서드다. limit가 없다면 스트림은 언바운드 상태가 된다.

generate는 상태가 없는 메서드, 즉 나중에 계산에 사용할 어떤 값도 저장해두지 않는 메서드를 활용한다.

위 예제에서 IntStream을 이용하면 박싱 연산 문제를 피할 수 있다. IntStream의 generate 메서드는 Supplier 대신에 IntSupplier를 인수로 받는다.

IntStream ones = IntStream.generate(() -> 1);

IntSupplier 인터페이스에 정의된 getAsInt를 구현하는 객체를 명시적으로 전달할 수도 있다.

IntStream twos = IntStream.generate(new IntSupplier(){
    public int getAsInt() {
        return 2;
    }
});

익명 클래스와 람다는 비슷하다. 하지만 익명클래스는 메서드의 연산을 커스터마이즈할 수 있는 상태 필드를 정의할 수 있다는 점이 다르다.

→ 부작용이 생길 수 있는 예제이다.

람다를 사용했을 때는 부작용이 없었다.(상태를 바꾸지 않기 때문)

// 피보나치 요소를 반환하도록 IntSupplier 구현
IntSupplier fib = new IntSupplier() {
    private int previous = 0;
    private int current = 1;
    public int getAsInt() {
        int oldPrevious = this.previous;
        int nextValue = this.previous + this.current;
        this.previous = this.current;
        this.current = nextValue;
        return oldPrevious;
    }
};
IntStream.generate(fib).limit(10).forEach(System.out::println);

IntSupplier 객체는 기존 피보나치 요소와 두 인스턴스 변수에 어떤 피보나치 요소가 들어있는지 추적하므로 가변 상태 객체다. getAsInt를 호출하면 객체 상태가 바뀌며 새로운 값을 생성한다.

iterate를 사용했을 때는 각 과정에서 새로운 값을 생성하면서도 기존 상태를 바꾸지 않는 순수한 불변 상태를 유지했다.