[모던 자바 인 액션] 스트림

필요성

데이터베이스에서 칼로리가 100보다 낮은 요리명을 선택하라는 SQL 쿼리문은 다음과 같다.

SELECT name FROM dishes WHERE calorie < 100

SQL 쿼리문에서는 반복자, 누적자 같은 것이 필요 없이 기대하는 것이 무엇인지 직접 표현할 수 있다. 즉, 질의를 어떻게 구현해야 할지 명시할 필요가 없으며, 구현은 자동으로 제공된다. 컬렉션에서도 이와 비슷한 기능을 만들고 싶다.

 

많은 요소를 포함하는 컬렉션의 성능을 높이고 싶다. 성능을 높이려면, 멀티코어 아키텍처를 활용해서 병렬로 컬렉션 요소를 처리해야 한다.

 

또한, 통화별로 트랜잭션을 그룹화하고 싶다면, 다음과 같이 구현해야 한다. 코드가 상당히 길다.

Map<Currency, List<Transaction>> transactionsByCurrencies = new HashMap<>();
for (Transaction transaction : transactions){
    Currency currency = transaction.getCurrency();
    List<Transaction> transactionForCurrency = transactionsByCurrencies.get(currency);
    if (transactionForCurrency == null){
        transactionForCurrency = new ArrayList<>();
        transactionsByCurrencies.put(currency, transactionForCurrency);
    }
    transactionForCurrency.add(transaction)
}

 

하지만, 스트림을 이용하여 다음과 같이 간단하게 구현할 수 있다.

Map<Currency, List<Transaction>> transactionsByCurrencies = transactions.stream()
                .collect(Collectors.groupingBy(Transaction::getCurrency));

 

이와 같은 필요성으로 등장한 것이 스트림이다!

 

스트림이란 무엇인가?

스트림을 이용하면, 선언형(데이터를 처리하는 임시 코드 대신 질의로 표현)으로 컬렉션 데이터를 처리할 수 있다. 또한, 스트림을 이용하면, 멀티스레드 코드를 구현하지 않아도 데이터를 투명하게 병렬로 처리할 수 있다.

 

아래는 이 장점들을 사용하여 100 미만 칼로리로 필터링하고, 칼로리를 기준으로 정렬하고, 이름을 반환하는 리스트를 얻는 것을 구현한 것이다.

List<Dish> menu = new ArrayList<>();
List<String> lowCaloricDishesName = menu.parallelStream()
        .filter((dish -> dish.getCalories() < 100))
        .sorted(Comparator.comparing(Dish::getCalories))
        .map(Dish::getName)
        .collect(Collectors.toList());

루프나 if 조건문 등의 제어 블록을 사용해서 동작을 구현하지 않아도, 선언형으로 동작을 수행할 수 있다. 또한 여러 연산을 연결해도 여전히 가독성과 명확성이 유지된다.

 

filter, sorted, map, collect 같은 연산은 고수준 빌딩 블록으로 이루어져 있으므로, 특정 스레드 모델에 제한되지 않고 자유롭게 어떤 상황에서든 사용할 수 있다. 결과적으로 스트림을 사용하는 과정에서 데이터 처리 과정을 병렬화하는 이점을 얻고, 스레드와 락을 걱정할 필요가 없다.

 

자바8의 스트림 API의 특징을 다음과 같이 요약할 수 있다.

• 선언형 : 더 간결하고 가독성이 좋아진다.
• 조립할 수 있음 : 여러 API를 연결하는 것을 말하며, 유연성이 좋아진다.
• 병렬화 : 성능이 좋아진다.

 

앞으로 사용할 코드는 다음과 같다.

public class Dish {
    private final String name;
    private final boolean vegetarian;
    private final int calories;
    private final Type type;

    public Dish(String name, boolean vegetarian, int calories, Type type) {
        this.name = name;
        this.vegetarian = vegetarian;
        this.calories = calories;
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public boolean isVegetarian() {
        return vegetarian;
    }

    public int getCalories() {
        return calories;
    }

    public Type getType() {
        return type;
    }

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

    public enum Type { MEAT, FISH, OTHER };
}

List<Dish> menu = Arrays.asList(
        new Dish("pork", false, 800, Dish.Type.MEAT),
        new Dish("beef", false, 700, Dish.Type.MEAT),
        new Dish("chicken", false, 400, Dish.Type.MEAT),
        new Dish("french fries", true, 530, Dish.Type.OTHER),
        new Dish("rice", true, 350, Dish.Type.OTHER),
        new Dish("season fruit", true, 120, Dish.Type.OTHER),
        new Dish("pizza", true, 550, Dish.Type.OTHER),
        new Dish("prawns", false, 300, Dish.Type.FISH),
        new Dish("salmon", false, 450, Dish.Type.FISH)
);

 

스트림 시작하기

스트림이란 '데이터 처리 연산을 지원하도록 소스에서 추출된 연속된 요소'로 정의할 수 있다.

• 연속된 요소 : 컬렉션과 마찬가지로 스트림은 특정 요소 형식으로 이루어진 연속된 값 집합의 인터페이스이다. 컬렉션의 주제는 데이터고, 스트림의 주제는 계산이다.
• 소스 : 스트림은 컬렉션, 배열, I/O 자원 등의 데이터 제공 소스로부터 데이터를 소비한다.
• 데이터 처리 연산 : filter, map, reduce, find, match, sort 등으로 데이터를 조작할 수 있다. 스트림 연산은 순차적으로 또는 병렬로 실행할 수 있다.
• 파이프라이닝 : 대부분의 스트림 연산은 스트림 연산끼리 연결해서 커다란 파이프라인을 구성할 수 있도록 스트림을 반환한다.
• 내부 반복 : 반복자를 이용해서 명시적으로 반복하는 컬렉션과 달리 스트림은 내부 반복자를 이용한다.

 

스트림과 컬렉션

컬렉션은 현재 자료구조가 포함하는 모든 값을 메모리에 저장하는 자료구조이다. 즉 컬렉션의 모든 요소는 컬렉션에 추가되기 전에 계산되어야 한다. 컬렉션에 요소를 추가하거나 컬렉션의 요소를 삭제할 수 있다. 마치 영화의 모든 프레임이 저장되어 있는 DVD와 유사하다. 

 

스트림은 이론적으로 요청할 때만 요소를 계산하는 고정된 자료구조다. 스트림에 요소를 추가하거나 스트림에서 요소를 제거할 수 없다. 마치 프레임을 받으면서 재생하는 인터넷 스트리밍과 유사하다. 스트림은 게으르게 만들어지는 컬렉션과 같다. 즉 사용자가 데이터를 요청할 때만 값을 생성한다.

 

딱 한 번만 탐색할 수 있다

탐색된 스트림의 요소는 소비되기 때문에, 한 번 탐색한 요소를 다시 탐색하려면 초기 데이터 소스에서 새로운 스트림을 생성해야 한다.

 

외부 반복과 내부 반복

컬렉션에 반복문을 사용하면 외부 반복이 일어나고, 스트림을 사용하면 내부 반복이 일어난다.

List<String> names = new ArrayList<>();
for (Dish dish : menu){
    names.add(dish.getName());
}

외부 반복은 방바닥에 어질러져 있는 장난감을 하나씩 찾아 상자에 넣는 과정을 반복하는 것과 같다.

 

List<String> names = menu.stream()
    .map(Dish::getName)
    .collect(Collectors.toList());

내부 반복은 방바닥에 어질러져 있는 장난감을 모두 찾아 한꺼번에 모아서 한 번에 상자에 넣는 것과 같다. 병렬적으로 처리하고, 최적화하여 처리하기 때문에 장점이 있다.

 

스트림은 내부 반복을 사용하는데, 이 반복 과정은 우리가 신경쓰지 않아도 된다. 하지만 이런 이점을 누리려면 반복을 숨겨주는 filter와 map 같은 연산이 정의되어 있어야 하는데, 자바 언어 설계자들이 이 연산들을 제작해두었다.

 

스트림 연산

List<String> highCaloricDish = menu.stream()
    .filter(dish -> dish.getCalories() > 300)
    .map(Dish::getName)
    .limit(3)
    .collect(Collectors.toList());

위 코드에서 연산을 두 그룹으로 분류할 수 있다.

• 중간 연산 : filter, map, limit와 같이 서로 연결되어 파이프라인을 형성하는 연산, 스트림을 반환한다.
• 최종 연산 : collect와 같이 스트림을 닫는 연산

 

중간 연산

중간 연산은 스트림을 반환하기 때문에 여러 중간 연산을 연결해서 질의를 만들 수 있다. 중간 연산의 중요한 특징은 최종 연산을 실행하기 전까지 아무 연산도 수행하지 않는 게으름이다. 모든 중간 연산을 최종 연산으로 한 번에 처리한다.

List<String> highCaloricDish = menu.stream()
                .filter(dish -> {
                    System.out.println("filtering:" + dish.getName());
                    return dish.getCalories() > 300;
                })
                .map(dish -> {
                    System.out.println("mapping:" + dish.getName());
                    return dish.getName();
                })
                .limit(3)
                .collect(Collectors.toList());

filtering:pork
mapping:pork
filtering:beef
mapping:beef
filtering:chicken
mapping:chicken

위 실행 결과에서 보듯이 스트림의 게으른 특성으로 최적화가 가능하다. 또한, filter와 map이 서로 다른 연산이지만 한 과정으로 병합된 것을 볼 수 있다. 이를 루프 퓨전이라고 한다.

 

최종 연산

최종 연산은 스트림 파이프라인에서 결과를 도출한다. 보통 최종 연산에 의해 List, Integer, void 등 스트림이 아닌 결과가 반환된다.

 

필터링

프레디케이트로 필터링

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

List<Dish> vegetarianMenu = menu.stream().filter(Dish::isVegetarian).collect(Collectors.toList());

 

고유 요소 필터링

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

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

 

스트림 슬라이싱

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

칼로리가 320 미만인 음식들을 선택하고 싶을 때, 필터링할 수도 있지만, 이미 정렬되어 있는 컬렉션에 대해서는 칼로리가 320 이상인 음식이 나오면 반복 작업을 중단하면 된다. 필터링은 모든 요소를 다 탐색해야 하는 단점이 있다.

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)
);
List<Dish> slicedMenu1 = specialMenu.stream()
        .takeWhile((Dish dish) -> dish.getCalories() < 320)
        .collect(Collectors.toList());
        
List<Dish> slicedMenu2 = specialMenu.stream()
        .takeWhile((Dish dish) -> dish.getCalories() < 320)
        .collect(Collectors.toList());

 

takeWhile은 처음부터 거짓이 되는 지점 전까지 조건에 부합한 것들을 남기는 것이고, dropWhile은 처음부터 거짓이 되는 지점 전까지 조건에 부합하는 것들을 버리는 것이다. 순차적으로 진행된다는 것에 유의해야 한다.

 

스트림 축소

스트림에서 주어진 값 이하의 크기를 갖는 새로운 스트림을 반환하는 limit(n) 메소드를 지원한다. 정렬 여부와 관계없이, 최대 n개의 요소를 반환한다. 

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

 

요소 건너뛰기

스트림에서 처음 n개의 요소를 제외한 스트림을 반환하는 skip(n) 메소드를 지원한다. 

List<Dish> dishes2 = menu.stream()
    .filter(d -> d.getCalories() > 300)
    .skip(2)
    .collect(Collectors.toList());

 

매핑

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

map 메소드는 인수로 함수를 제공받아 제공받은 함수를 스트림의 각 요소에 적용한 결과가 새로운 요소로 매핑된다.('고친다'라는 개념보다는 '새로운 버전을 만든다'라는 개념에 가까우므로 '매핑'이라는 단어를 사용한다).

List<String> dishNames = menu.stream().map(Dish::getName).collect(Collectors.toList());

위 코드와 같이, 본래는 List<Dish>였지만, List<String>으로 변환되었다.

 

예제로 요리명의 길이를 알고 싶다면, 아래와 같이 구현한다.

List<Integer> dishNameLengths = menu.stream()
                .map(Dish::getName)
                .map(String::length)
                .collect(Collectors.toList());

 

스트림 평면화

단어로 이루어진 리스트로부터 고유 문자로 이루어진 리스트를 반환하려고 하면, 단어를 모두 분리하고, 중복을 없애면 결과는 아래와 같다. List<String>이 나와야 하는데, List<String[]>이 나온다.

List<String[]> characters = words.stream()
    .map(word -> word.split(""))
    .distinct()
    .collect(Collectors.toList());

 

배열을 스트림으로 만드는 Arrays.stream을 map으로 적용해보자.

words.stream()
    .map(word -> word.split(""))
    .map(Arrays::stream)
    .distinct()
    .collect(Collectors.toList())

List<Stream<String>>이 되면서 문제가 해결되지 않는다.

 

flatMap을 사용하여 문제를 해결할 수 있다. 

words.stream()
    .map(word -> word.split(""))
    .flatMap(Arrays::stream)
    .distinct()
    .collect(Collectors.toList());

flatMap은 각 배열을 스트림이 아니라 스트림의 콘텐츠로 매핑한다. 즉, flatMap은 하나의 평면화된 스트림을 반환한다.

 

제곱 리스트 만들기는 아래와 같이 구현할 수 있다.

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

 

두 리스트의 수로 이루어진 숫자 쌍의 리스트는 아래와 같다.

List<Integer> numbers1 = Arrays.asList(1, 2, 3);
List<Integer> numbers2 = Arrays.asList(4, 5);

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

filter, map 모두 stream을 반환한다는 것에 유의하자. flatMap이 아니라 map일 경우, List<Stream<int[]>>를 반환한다.

 

검색과 매칭

anyMatch

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

if (menu.stream().anyMatch(Dish::isVegetarian)){
    System.out.println("The menu is (somewhat) vegetarian friendly");
}

anyMatch는 불리안을 반환하므로, 최종 연산이다.

 

allMatch 

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

boolean isHealthy = menu.stream().allMatch(dish -> dish.getCalories() < 300);

 

noneMatch

스트림의 모든 요소가 주어진 프레디케이트와 일치하지 않는지 확인한다. allMatch와 반대 연산이다.

boolean isNotHealthy = menu.stream().noneMatch(dish -> dish.getCalories() >= 300);

 

anyMatch, allMatch, noneMatch는 쇼트 서킷 기법을 수행한다. 즉, 전체 스트림을 처리하지 않아도 결과를 반환할 수 있다. 예를 들어, anyMatch의 경우, 조건에 맞는 것이 하나라도 있으면 바로 참, allMatch와 noneMatch의 경우, 조건에 맞지 않는 것이 하나라도 있으면 바로 거짓이 된다.

 

요소 검색

findAny 메소드는 현재 스트림에서 임의의 요소를 반환한다. 스트림 파이프라인은 쇼트 서킷을 이용해서 결과를 찾는 즉시 실행을 종료한다.

Optional<Dish> dish = menu.stream()
    .filter(Dish::isVegetarian)
    .findAny();

 

Optional이란?

Optional<T> 클래스는 값의 존재나 부재 여부를 표현하는 컨테이너 클래스이다. 위 코드에서 findAny가 아무 요소도 반환하지 않을 수 있다. null은 쉽게 에러를 발생시키기 때문에 자바8 설계자는 안전하게  Optional<T>를 만들었다.

• isPresent() : Optional이 값을 포함하면 true, 아니라면 false 반환
• ifPresent()(Consumer<T> block) : 값이 있으면 반환 형식 void인 블록을 실행한다.
• T get() : 값이 존재하면 값을 반환하고, 값이 없으면 NoSuchElementException을 일으킨다.
• T orElse(T other) : 값이 있으면 값을 반환하고, 값이 없으면 other을 반환한다. 

menu.stream()
    .filter(Dish::isVegetarian)
    .findAny()
    .ifPresent(dish -> System.out.println(dish.getName()));

 

 

첫 번째 요소 찾기

스트림에서 논리적인 아이템 순서가 정해져 있을 때, 첫 번째 요소를 찾으려면, findFirst()를 이용한다.

List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4);
Optional<Integer> first = someNumbers.stream()
        .map(n -> n * n)
        .filter(n -> n % 3 == 0)
        .findFirst();

 

findFirst의 존재 이유

병렬 스트림일 때, 실행에 있어서 첫 번째 요소를 찾기가 어렵다. 따라서 요소 반환 순서가 상관이 없다면, findFirst보다는 병렬 스트림에서는 제약이 적은 findAny를 사용한다.

 

리듀싱

모든 스트림 요소를 처리해서 값으로 도출하는 것을 리듀싱 연산이라고 한다.

 

요소의 합

int sum = 0;
for (int x : numbers){
    sum += x;
}

int sum = numbers.stream().reduce(0, (x, y) -> x + y);

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

 

 

reduce를 이용하여 스트림에서 요소의 합을 구할 수 있다. 이 때, reduce는 두 개의 인수를 갖는다.

• 초깃값 0
• 두 요소를 조합해서 새로운 값을 만드는 BinaryOperator<T>

 

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

초깃값을 지정하지 않을 경우, stream에 아무 요소도 없을 경우를 대비하여 Optional 객체가 반환된다.

 

최댓값과 최솟값

reduce를 이용해서 스트림에서 최댓값과 최솟값을 찾을 수 있다. 이 때, reduce는 두 인수를 받는다.

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

Optional<Integer> max = numbers.stream().reduce(Integer::max);
Optional<Integer> max = numbers.stream().reduce((x, y) -> x > y ? x : y);

 

reduce 메소드의 장점과 병렬화

reduce를 이용하면, 내부 반복이 추상화되면서, 내부 구현에서 병렬로 reduce를 실행할 수 있게 된다.

 

실전 연습

public class Trader {
    private final String name;
    private final String city;

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

    public String getName() {
        return name;
    }

    public String getCity() {
        return city;
    }

    @Override
    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 trader;
    }

    public int getYear() {
        return year;
    }

    public int getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "{" +
                "trader=" + trader +
                ", year=" + year +
                ", value=" + value +
                '}';
    }
}

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)
)

 

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

List<Transaction> tr2011 = transactions.stream()
    .filter(t -> t.getYear() == 2011)
    .sorted(Comparator.comparing(Transaction::getValue))
    .collect(Collectors.toList());

 

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

List<String> cities = transactions.stream()
    .map(t -> t.getTrader().getCity())
    .distinct()
    .collect(Collectors.toList());

 

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

List<Trader> traders = transactions.stream()
    .map(Transaction::getTrader)
    .filter(trader -> trader.getCity().equals("Cambridge"))
    .distinct()
    .sorted(Comparator.comparing(Trader::getName))
    .collect(Collectors.toList());

 

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

String traderStr = transactions.stream()
    .map(Transaction::getTrader)
    .map(Trader::getName)
    .distinct()
    .sorted()
    .reduce("", (n1, n2) -> n1 + " " + n2);

 

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

boolean milanBased = transactions.stream()
    .anyMatch(transaction -> transaction.getTrader().getCity().equals("Milan"));

 

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

transactions.stream()
                .filter(transaction -> transaction.getTrader().getCity().equals("Cambridge"))
                .map(Transaction::getValue)
                .forEach(System.out::println);

 

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

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

 

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

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

 

숫자형 스트림

int calories = menu.stream()
    .map(Dish::getCalories)
    .reduce(0, Integer::sum);

reduce 메소드로 합을 구할 때, 원래 calrories는 int이므로, Integer로 박싱하고, 합계를 계산하기 위해 기본형으로 언박싱 하는 비용이 포함된다. 스트림에 sum 메소드가 있다면 좋겠지만, sum 메소드는 없다. Stream<Dish>일 경우, 무엇을 합해야 하는지 알 수 없기 때문이다. 

 

기본형 특화 스트림

자바 8에서는 IntStream, DoubleStream, LongStream과 같은 기본형 특화 스트림을 제공한다. 각각의 인터페이스는 sum, max와 같이 숫자 관련 리듀싱 연산 수행 메소드를 제공한다. 또한, 필요할 때 다시 객체 스트림으로 복원하는 기능도 제공한다. 특화 스트림은 오직 박싱 과정에서 일어나느 효율성과 관련이 있고, 추가 기능을 제공하지는 않는다.

 

숫자 스트림으로 매핑

int sum = menu.stream()
                .mapToInt(Dish::getCalories)
                .sum();

 

mapToInt 메소드로 Stream<Integer>가 아닌 기본형 특화 스트림인 IntStream을 반환하고, 메소드를 사용한다. sum, min, max, average 등도 이용할 수 있다.

 

객체 스트림으로 복원하기

boxed 메소드를 이용해서 기본형 특화 스트림을 일반 스트림으로 변환할 수 있다.

IntStream intStream = menu.stream().mapToInt(Dish::getCalories);
Stream<Integer> boxed = intStream.boxed();

 

기본값 : OptionalInt

sum이 스트림 요소가 없으면, 0을 기본값으로 반환하는 것과 달리, max는 Optional 객체를 반환한다. 스트림 요소가 없을 때 0을 반환할 경우, 최댓값이 0이라는 것인지 없어서 0인지 알 수 없기 때문이다.

OptionalInt maxCalories = menu.stream()
    .mapToInt(Dish::getCalories)
    .max();
    
int max = maxCalories.orElse(-999999);

 

숫자 범위

특정 범위의 숫자를 이용해야 하는 상황일 때, range와 rangeClosed라는 두 가지 정적 메소드를 사용해서 기본형 특화 스트림을 생성할 수 있다. range는 두 번째 인수인 종료값이 포함되지 않는다.

IntStream evenNumbers = IntStream.range(1, 100).filter(i->i%2==0);
System.out.println(evenNumbers.count());

IntStream evenNumbers2 = IntStream.rangeClosed(1, 100).filter(i->i%2==0);
System.out.println(evenNumbers2.count());

 

스트림 만들기

값으로 스트림 만들기

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

Stream<String> stream = Stream.of("Modern", "Java", "In", "Action");

 

배열로 스트림 만들기

배열을 인수로 받는 정적 메소드 Arrays.stream을 이용해서 스트림을 만들 수 있다.

int[] numbers = {1,2,3,4,5};
IntStream stream = Arrays.stream(numbers);

 

파일로 스트림 만들기

파일을 처리하는 등의 I/O 연산에 사용하는 자바의 비블록 I/O API도 스트림 API를 활용할 수 있도록 업데이트 되었다. java.nio.file.Files의 많은 정적 메소드가 스트림을 반환한다. 예를 들어 Files.lines는 주어진 파일의 행 스트림을 문자열로 반환한다.

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){

}

 

함수로 무한 스트림 만들기

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

 

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는 두 번째 매개변수로 프레디케이트를 지원한다. 따라서, 추가 메소드를 붙이지 않아도 구현할 수 있다.

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

 

이것을 다르게 표현할 수 있는 방법은 무엇일까? filter를 생각할 순 있지만, iterate가 무한 스트림을 생성하면, filter는 무한 개의 요소를 봐야하므로 끝나지 않는다.

 

takeWhile을 이용하는 것이 바람직하다.

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

 

generate 메소드

무한 스트림을 만들 수 있지만, iterate와 달리 생산된 각 값을 연속적으로 계산하지는 않는다. generate는 Supplier<T>를 인수로 받아서 새로운 값을 생산한다.

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

 

 

컬렉터란 무엇인가?

위에서 비교한 결과 명령형 프로그래밍에 비해 함수형 프로그래밍이 얼마나 편리한지 명확하게 보여준다. 함수형 프로그래밍에서는 무엇을 원하는지 직접 명시할 수 있어서 어떤 방법으로 이를 얻을지는 신경쓰지 않아도 된다.

 

Collector 인터페이스 구현은 스트림의 요소를 어떤 식으로 도출할지 지정한다.

 

다수준으로 그룹화를 수행할 때 명령형 코드에서는 문제를 해결하는 과정에서 다중 루프와 조건문을 추가하며 가독성과 유지 보수성이 크게 떨어지지만, 함수형 프로그래밍에서는 필요한 컬렉터를 쉽게 추가할 수 있다.

 

고급 리듀싱 기능을 수행하는 컬렉터

함수형 API의 장점으로 높은 수준의 조합성과 재사용성을 꼽을 수 있다. collect로 결과를 수집하는 과정을 간단하면서도 유연한 방식으로 정의할 수 있다는 것이 컬렉터의 최대 장점이다. 스트림에 collect를 호출하면, 스트림 요소에 리듀싱 연산이 수행된다. 

collect에서는 리듀싱 연산을 이용해서 스트림의 각 요소를 방문하면서 컬렉터가 작업을 처리한다.

 

보통 함수를 요소로 변환할 때는 컬렉터를 적용하며 최종 결과를 저장하는 자료구조에 값을 누적한다.

 

미리 정의된 컬렉터

Collectors에서 제공하는 메소드의 기능은 크게 세 가지로 구분할 수 있다.

• 스트림 요소를 하나의 값으로 리듀스하고 요약
• 요소 그룹화
• 요소 분할

 

리듀싱과 요약

개수 구하기

Long howManyDishes = menu.stream().collect(Collectors.counting());

기본형 특화 스트림으로 바꾸는 작업을 하지 않아도 된다.

 

스트림에서 최댓값과 최솟값 검색

Comparator<Dish> dishCaloriesComparator = Comparator.comparingInt(Dish::getCalories);

Optional<Dish> mostCalorieDish = menu.stream()
        .collect(Collectors.maxBy(dishCaloriesComparator));

비교 대상을 지정하여 Comparator를 만들고, maxBy에 전달한다. menu가 비어있다면, 반환되는 것이 없기 때문에 안전하게 Optional로 반환한다.

 

요약 연산

합계

스트림에 있는 객체의 숫자 필드의 합계나 평균 등을 반환하는 연산에도 리듀싱 기능이 자주 사용된다. 이러한 연산을 요약 연산이라고 부른다.

int totalCalories = menu.stream().collect(Collectors.summingInt(Dish::getCalories));

 

평균

int 요소들을 이용하여 double 타입의 평균을 반환한다.

double avgCalories = menu.stream().collect(Collectors.averagingInt(Dish::getCalories));

 

요소 수, 합계, 평균, 최댓값, 최솟값

IntSummaryStatistics menuStatistics = menu.stream().collect(Collectors.summarizingInt(Dish::getCalories));
System.out.println(menuStatistics);	// IntSummaryStatistics{count=9, sum=4200, min=120, average=466.666667, max=800}

 

문자열 연결

컬렉터에 joining 팩토리 메소드를 이용하면 스트림의 각 객체에 toString 메소드를 호출해서 추출한 모든 문자열을 하나의 문자열로 연결해서 반환한다.

String menuNames = menu.stream().map(Dish::getName).collect(Collectors.joining(", "));
// pork, beef, chicken, french fries, rice, season fruit, pizza, prawns, salmon

 

그룹화

데이터 집합을 하나 이상의 특성으로 분류해서 그룹화하는 연산도 데이터베이스에서 많이 수행되는 작업이다. 위에서 확인했듯이 명령형으로 그룹화를 구현하려면 까다롭고 에러도 많이 발생한다. 하지만, 자바8의 함수형을 이용하면, 가독성 있는 한 줄의 코드로 그룹화를 구현할 수 있다.

Map<Dish.Type, List<Dish>> dishesByType = menu.stream()
        .collect(Collectors.groupingBy(Dish::getType));
System.out.println(dishesByType);
// {OTHER=[french fries, rice, season fruit, pizza], MEAT=[pork, beef, chicken], FISH=[prawns, salmon]}

 

그룹화 연산의 결과로 그룹화 함수(분류 함수)가 반환하는 키 그리고 각 키에 대응하는 스트림의 모든 항목 리스트를 값으로 갖는 맵이 반환된다.

 

단순한 속성 접근자 대신 더 복잡한 분류 기준이 필요한 상황에서는 메소드 참조를 분류 함수로 사용할 수 없다. 이럴 때는 람다 함수를 이용하여 그룹화할 수 있다.

public enum CaloricLevel {DIET, NORMAL, FAT};

Map<CaloricLevel, List<Dish>> dishesByCaloricLevel = menu.stream()
        .collect(Collectors.groupingBy((dish -> {
            if (dish.getCalories() <= 400) return CaloricLevel.DIET;
            else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
            else return CaloricLevel.FAT;
        })));

 

그룹화된 요소 조작

요소를 그룹화한 다음에는 각 결과 그룹의 요소를 조작하는 연산이 필요하다. 예를 들어, 500칼로리가 넘는 요리만 그룹화한다고 할 때, 필터링 후에 그룹화를 하면 다음과 같은 결과가 초래된다.

Map<Dish.Type, List<Dish>> collect = menu.stream()
        .filter(dish -> dish.getCalories() > 500)
        .collect(Collectors.groupingBy(Dish::getType));
System.out.println(collect);
// {OTHER=[french fries, pizza], MEAT=[pork, beef]}

문제는 FISH에 해당하는 것들은 500칼로리 이하이기 때문에, 키 자체가 사라진다.

 

groupingBy 메소드는 두 번째 인수를 갖도록 오버로드해 이 문제를 해결하게 해준다.

Map<Dish.Type, List<Dish>> caloricDishesByType = menu.stream()
        .collect(Collectors.groupingBy(Dish::getType, Collectors.filtering(dish -> dish.getCalories() > 500, Collectors.toList())));
System.out.println(caloricDishesByType);
// {FISH=[], MEAT=[pork, beef], OTHER=[french fries, pizza]}

 

Map<String, List<String>> disTags에서 각 형식의 요리의 태그를 간편하게 추출할 수 있다.

Map<Dish.Type, Set<String>> collect = menu.stream()
                .collect(Collectors.groupingBy(Dish::getType,
                        Collectors.flatMapping(dish -> dishTags.get(dish.getName()), Collectors.toSet())));

 

다수준 그룹화

Collectors.groupingBy는 일반적인 분류 함수와 컬렉터를 인수로 받는다. 즉, 바깥쪽 groupingBy 메소드에 스트림의 항목을 분류할 두 번째 기준을 정의하는 내부 groupingBy를 전달해서 두 수준으로 스트림의 항목을 그룹화할 수 있다.

Map<Dish.Type, Map<CaloricLevel, List<Dish>>> dishesByTypeCaloricLevel = menu.stream()
    .collect(Collectors.groupingBy(Dish::getType,
            Collectors.groupingBy((dish -> {
                if (dish.getCalories() <= 400) return CaloricLevel.DIET;
                else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
                else return CaloricLevel.FAT;
            }))));
            
// {FISH={DIET=[prawns], NORMAL=[salmon]}, MEAT={DIET=[chicken], FAT=[pork], NORMAL=[beef]}, OTHER={DIET=[rice, season fruit], NORMAL=[french fries, pizza]}}

 

서브그룹으로 데이터 수집

groupingBy의 두 번째 인수로 넘겨주는 컬렉터의 형식은 제한이 없다. groupingBy(f)는 사실 groupingBy(f, toList())의 축약형이다.

Map<Dish.Type, Long> typesCount = menu.stream()
        .collect(Collectors.groupingBy(Dish::getType, Collectors.counting()));
System.out.println(typesCount);

// {FISH=2, MEAT=3, OTHER=4}

 

요리의 종류마다 가장 높은 칼로리는 다음과 같이 구현할 수 있다.

Map<Dish.Type, Optional<Dish>> mostCaloricByType = menu.stream()
    .collect(Collectors.groupingBy(Dish::getType,
            Collectors.maxBy(Comparator.comparingInt(Dish::getCalories))));

 

마지막 그룹화 연산에서 맵의 모든 값을 Optional로 감싸고 싶지 않을 수 있다. 즉, 다음처럼 팩토리 메서드 Collectors.collectingAndThen으로 컬렉터가 반환한 결과를 다른 형식으로 활용할 수 있다.

Map<Dish.Type, Dish> mostCaloricByType = menu.stream()
    .collect(Collectors.groupingBy(Dish::getType,
            Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparingInt(Dish::getCalories)), Optional::get)
    ));

리듀싱 컬렉터는 Optional.empty()를 반환하지 않으므로, 안전한 코드이다.

 

분할

분할은 분할 함수라 불리는 프레디케이트를 분류 함수로 사용하는 특수한 그룹화 기능이다. 분할 함수는 불리언을 반환하므로 맵의 키 형식은 Boolean이다. 결과적으로 그룹화 맵은 두 개의 그룹으로 분류된다.

Map<Boolean, List<Dish>> partitionedMenu = menu.stream().collect(Collectors.partitioningBy(Dish::isVegetarian));

 

groupingBy와 비슷하게 두 번째 인수에 groupingBy를 전달할 수 있다.

Map<Boolean, Map<Dish.Type, List<Dish>>> vegeterianDishesByType = menu.stream().collect(Collectors.partitioningBy(Dish::isVegetarian, Collectors.groupingBy(Dish::getType)));