[JAVA] 스트림(Stream)

1. 스트림(Stream)?

많은 수의 데이터를 다룰 때 for문이나 Iterator를 사용하여 코드를 작성해왔다. 또한 데이터의 형태마다 다른 방식으로 다뤄야 했다. 예를들어, 데이터의 정렬을 예로 들자면 컬렉션 클래스 중 List를 정렬할 때에는 Collections.sort()를, 배열을 정렬할 때는 Arrays.sort()를 사용해야했다. 같은 기능이고 같은 메서드임에도 다르게 호출을 해야만 했다.

이러한 문제점들을 해결하기 위해 만든 것이 바로 자바 8부터 등장한 스트림(Stream)이다. 어떤 데이터이든 같은 방식으로 다룰 수 있게 만든것이다. 스트림을 이용하면, 배열이나 컬렉션뿐만 아니라 파일에 저장된 데이터도 모두 같은 방식으로 다룰 수 있기 때문에 코드의 재사용성이 높아진다. 예제를 보면 한 눈에 이해할 수 있다.

String[] strArr = { "aaa", "bbb", "ccc" };
List strList = Arrays.asList(strArr);
 
Stream strStream1 = strList.stream();    // 스트림을 생성
Stream strStream2 = Arrays.stream(strArr);    // 스트림을 생성
 
strStream1.sorted().forEach(System.out::println);
strStream2.sorted().forEach(System.out::println);
 
// 이전 코드
/*
Arrays.sort(strArr);
Collections.sort(strList);
for (String str : strArr) 
    System.out.println(str);
for (String str : strList)
    System.out.println(str);
*/

스트림을 사용한 코드가 간결하고 이해하기 쉬우면서 재사용성이 높다는 것을 알 수 있다. 

여기서 스트림은 원본데이터를 변경하지 않는다. 

원본데이터에서 stream을 생성하여 사용하기 때문이다. 스트림을 통해 정렬한 결과를 사용하고 싶다면 컬렉션이나 배열에 담아서 반환할 수도 있다.

스트림은 일회용이다.

스트림은 Iterator처럼 일회용이다. Iterator로 컬렉션의 모든 요소를 읽고 난 후에 다시 사용할 수 없는 것처럼, 스트림도 한번 사용하면 닫히기 때문에 재사용이 불가능하다.

스트림은 작업을 내부 반복으로 처리한다.

내부 반복이란, 반복문을 메서드의 내부에 넣었다는것을 의미한다. 위의 예제코드에서 forEach()는 스트림에 정의된 메서드 중 하나로 매개변수에 대입된 람다식을 모든 데이터에 대해 for문 돌리는 것이라고 생각하면 

void forEach(Consumer action) {
    Objects.requireNonNull(action);    // 매개변수의 널 체크
 
    for(T t : src) {    // 내부반복 
        action.accept(T);
    }
}

스트림은 다양한 연산을 제공하여 복잡한 작업을 간단하게 처리할 수 있다. 마치 DB의 쿼리와 비슷하다. 여기서 연산이란 스트림에서 정의된 메서드 중에 데이터를 다루는 메서드를 의미한다. (한마디로 메서드)

스트림이 제공하는 연산은 중간연산과 최종연산으로 분류된다.

중간연산은 연산 결과를 스트림으로 반환하기 때문에 연속해서 연결할 수 있다. 그에 반해 최종 연산은 스트림의 요소를 소모하면서 연산을 수행하기 때문에 단 한번만 연산이 가능하다.

stream.distinct().limit(5).sorted().forEach(System.out::println)

Stream에 정의된 연산은 책을 참고하자.

중간연산은 map()과 flatMap(), 최종 연산은 reduce()와 collect()가 핵심이다. 나머지는 이해하기 쉽고 사용법도 간단하다.

지연된 연산

스트림 연산에서 중요한 점은 최종 연산이 수행되기 전까지는 중간 연산이 수행되지 않는다. 스트림에 대해 distinct()나 sort()같은 중간 연산을 호출해도 즉각적인 연산이 수행되는 것이 아니다. 최종 연산이 호출되어야 중간 연산을 거쳐 최종 연산이 수행된다.

Stream<Integer>와 IntStream

스트림은 기본적으로 Stream<T>이지만, 오토박식&언박싱으로 인한 비효율을 줄이기 위해 데이터를 기본형으로 다루는 스트림, IntStream, LongStream, DoubleStream이 제공된다. 일반적으로 Stream<Integer> 대신 IntStream을 사용하는 것이 더 효율적이라고 한다. 또한 IntStream에는 int타입의 값을 다루는데 유용한 메서드들이 포함되어 있다고 한다.

병렬 스트림

스트림의 장점으로 병렬처리가 쉽다는 것이다. parallel()이라는 메서드를 호출해서 병렬로 연산을 수행하도록 하면된다. 그와 반대로 직렬 스트림은 sequential()을 호출하면 되는데 모든 스트림은 기본적으로 직렬 스트림이기 때문에 sequential()은 굳이 호출할 필요 없다.

2. 스트림 만들기

스트림으로 작업하기 위해서 스트림부터 생성하자. 스트림이 뽑아낼 수 있는 대상은 많기 때문에 대상에 따라 정리해보자.

컬렉션

배열

특정 범위의 정수

임의의 수

람다식

파일

빈 스트림

두 스트림의 연결

컬렉션

컬렉션은 Collection 클래스에 strearm()이 정의되어 있다. 따라서 Collection을 상속받은 List와 Set을 구현한 컬렉션 클래스들은 모두 이 메서드로 스트림을 생성할 수 있다. 예를 들어 List로부터 스트림을 생성해보자.

List list = Arrays.asList(1,2,3,4,5);
Stream intStream = list.stream();
intStream.forEach(System.out::println);
intStream.forEach(System.out::println);    // 에러 발생. 스트림이 이미 닫힘.

[실행결과]

1

2

3

4

5

java.lang.IllegalStateException: 

  stream has already been operated upon or closed

한 가지 주의할 점은 forEach()를 jstl의 forEach와 같이 생각하면 되는데 스트림의 요소를 소모하면서 작업을 수행하기 때문에 한 번 수행된 뒤에는 같은 스트림에 또 forEach()를 호출할 수 없다. 그래서 스트림의 요소를 한번 더 출력하려면 스트림을 새로 생성해야한다.

배열

배열로 스트림을 생성하는 메서드는 다음과 같이 Stream과 Arrays에 static메서드로 정의되어 있다.

Stream.of(T... values) // 가변인자
Stream.of(T[])
Arrays.stream(T[])
Arrays.stream(T[] array, int startInclusive, int endExclusive)

예를들면 다음과 같다.

Stream strStream = Stream.of("a", "b", "c"); // 가변인자
Stream strStream = Stream.of(new String[] {"a", "b", "c"});
Stream strStream = Arrays.stream(new String[] {"a", "b", "c"});
Stream strStream = Arrays.stream(new String[] {"a", "b", "c"}, 1, 3)

그리고 int, long, double과 같은 기본형 배열을 데이터로하는 스트림을 생성하는 메서드도 있다.

IntStream IntStream.of(int... values)
IntStream IntStream.of(int[])
IntStream Arrays.stream(int[])
IntStream Arrays.stream(int[] array, int startInclusive, int endExclusive)

특정 범위의 정수

앞에서도 언급했지만 기본형 데이터를 다루는 스트림은 기본형 데이터를 좀 더 유용하게 다룰 수 있는 메서드가 있다고 했는데, IntStream과 LongStream은 다음과 같이 지정된 범위의 연속된 정수를 스트림으로 생성해서 반환하는 range()와 rangeClosed()메서드를 가지고 있다.

IntStream IntStream.range(int begin, int end)
IntStream IntStream.rangeClosed(int begin, int end)

둘의 차이점은 range()는 끝에 end가 범위에 포함되지 않고, rangeClosed()는 포함된다.

IntStream intStream = IntStream.range(1, 5)    // 1,2,3,4
IntStream intStream = IntStream.rangeClosed(1, 5)    // 1,2,3,4,5

임의의 수

난수를 생성할 때 사용하는 Random클래스에는 아래와 같은 인스턴스 메서드들이 포함되어 있다. 이 메서드들은 해당 타입의 난수들로 이루어진 스트림을 반환한다.

IntStream ints()
LongStream longs()
DoubleStream doubles()

여기서 반환되는 스트림들은 크기가 정해지지않은 '무한 스트림'이므로 limit()도 같이 사용해서 스트림의 크기를 제한해주어야 안전한 프로그램이 된다. limit()은 스트림의 개수를 지정하는데 사용되며, 무한 스트림을 유한 스트림으로 만들어 준다.

IntStream intStream = new Random().ints();    // 무한 스트림
intStream.limit(5).forEach(System.out::println);

[실행결과]

1443532478

-2115253488

1079105334

941471356

178558647

다른 방법으로는 매개변수로 스트림의 크기를 지정하여 유한 스트림을 반환하도록 할 수 있다.

IntStream ints(long streamSize)
LongStream longs(long streamSize)
DoubleStream doubles(long streamSize)

또한 위의 메서드를 통해 생성된 스트림의 난수는 아래의 범위를 갖는다.

Integer.MIN_VALUE <= ints() <= Integer.MAX_VALUE
Long.MIN_VALUE <= longs() <= Long.MAX_VALUE
0.0 <= doubles() < 1.0

지정된 범위(begin ~ end)의 난수를 발생시키는 스트림을 얻는 메서드는 아래와 같다. 단, end는 범위에 포함되지 않는다.

IntStream ints(int begin, int end)
LongStream longs(long begin, long end)
DoubleStream doubles(double begin, double end)
 
IntStream ints(long streamSize, int begin, int end)
LongStream longs(long streamSize, long begin, long end)
DoubleStream doubles(long streamSize, double begin, double end)

람다식

Stream 클래스의 iterate()와 generate()는 람다식을 매개변수로 받아서, 이 람다식에 의해 계산되는 값들을 요소로 하는 무한 스트림을 생성한다.

static  Stream  iterate(T seed, UnaryOperator f)
static  Stream  generate(Supplier s)

iterate()는 씨앗값(seed)으로 지정된 값부터 시작해서, 람다식 f에 의해 계산된 결과를 다시 seed값으로 해서 계산을 반복한다. 아래의 evenStream은 0부터 시작해서 값이 2씩 계속 증가한다.

Stream evenStream = Stream.iterate(0, n->n+2);    // 0, 2, 4, 6, ...

generate()는 iterate()와 달리 계산된 결과를 다시 seed값으로 해서 계산하지 않는다. 또한 매개변수의 타입은 Supplier<T>로 매개변수가 없는 람다식만을 허용한다.

Stream randomStream = Stream.generate(Math::random);
Stream oneStream = Stream.generate(()->1));

※ 주의사항 : iterate()와 generate()로 생성된 스트림은 기본형 스트림 타입의 참조변수로 다룰 수 없다.

IntStream evenStream = Stream.iterate(0, n->n+2);    // 에러
DoubleStream randomStream = Stream.generate(Math::random);    // 에러

굳이 필요하다면, 아래와 같이 mapToInt()와 같은 메서드로 변환해야 한다. 반대로 IntStream타입의 스트림을 Stream<Integer>타입으로 변환하려면, boxed()를 사용하면 된다.

IntStream evenStream = Stream.iterate(0, n->n+2).mapToInt(Integer::valueOf);
Stream stream = evenStream.boxed();    // IntStream -> Stream

파일

java.nio.file.Files패키지에 파일을 다루는 유용한 메서드들이 있다. 그 중 list()는 지정된 디렉토리(dir)에 있는 파일의 목록을 소스로 하는 스트림을 생성해서 반환한다.

Stream Files.list(Path dir)

그리고, 파일의 한 행을 요소로 하는 스트림을 생성하는 메서드도 있다.

Stream Files.lines(Path path)
Stream Files.lines(Path path, Charset cs)
Stream lines()

아래 세번째 메서드는 BufferdReader클래스에 속한 것인데, 파일 뿐만 아니라 다른 입력대상으로부터도 데이터를 행단위로 읽어올 수  있다.

빈 스트림

요소가 하나도 없는 텅 빈 스트림을 생성할 수도 있다. 스트림에 연산을 수행한 결과가 하나도 없을 때, null보다 빈 스트림을 반환하는 것이 에러를 줄일 수 있기 때문에 더 낫다.

Stream emptyStream = Stream.empty();    // 빈 스트림 생성
long count = emptyStream.count()    // 0

count()는 요소의 개수를 반환한다.

두 스트림의 연결

Stream의 static메서드인 concat()을 사용하면, 두 스트림을 하나로 연결할 수 있다. 이 때 연결하는 두 스트림의 요소는 같은 타입이어야 한다.

Stream strs1 = Stream.of(str1);
Stream strs2 = Stream.of(str2);
Stream strs3 = Stream.concat(stgr1, str2);    // 두 스트림을 하나로 연결

3. 스트림의 중간연산

스트림 자르기 - skip(), limit()

스트림 일부를 자를 때 skip()과 limit()을 사용한다. skip(3)은 처음 3개의 요소를 건너뛰고, limit(5)는 스트림의 요소를 최대 5개로 제한한다.

Stream skip(long n)
Stream limit(long maxSize)

예를들어 10개의 요소를 가진 스트림에 skip(3)과 limit(5)를 적용하면 4번째 요소부터 5개를 가진 스트림을 반환한다.

IntStream intStream = IntStream.rangeClosed(1, 10);    // 1~10의 요소를 가진 스트림 생성
intStream.skip(3).limit(5).forEach(System.out::println);

[실행 결과]

4

5

6

7

8

기본형 스트림에도 skip()과 limit()이 정의 되어 있고 반환 타입이 기본형 스트림이라는 것만 다르다.

스트림 요소 걸러내기 - filter(), distinct()

distinct()는 중복요소들을 제거하고 filter()는 조건에 맞지 않는 요소를 걸러낸다. 쿼리와 아주 흡사하다.

Stream filter(Predicate predicate)

filter는 매개변수로 Predicate를 필요로 하는데, 아래와 같이 연산결과가 boolean 인 람다식을 사용해도 된다.

IntStream intStream = IntStream.rangeClosed(1, 10);    // 1~10의 요소를 가진 스트림 생성
intStream.filter(i -> i%2 == 0).forEach(System.out::println);    // 2 4 6 8 10

필요하다면 filter()를 다른 조건으로 여러 번 사용할 수도 있다.

정렬 - sorted()

스트림을 정렬할 때는 sorted()를 사용하면 된다.

Stream sorted()
Stream sorted(Comparator comparator)

sorted()는 지정된 Comparator로 스트림을 정렬하는데, Comparator 대신 int값을 반환하는 람다식을 사용해도 된다. Comparator를 지정하지 않으면 스트림 요소의 기본 정렬 기준으로 정렬한다. 단, 스트림의 요소가 Comparable을 구현한 클래스가 아니면 예외가 발생한다.

Stream strStream = Stream.of("dd", "aaa", "CC", "cc", "b");
strStream.sorted().forEach(System.out::println);

[실행결과]

CC

aaa

b

cc

dd

Comparator의 static메서드

naturalOrder()
reverseOrder()
comparing(Function(T, U) keyExtractor)
comparing(Function(T, U) keyExtractor, Comparator keyComparator)
comparingInt(ToIntFunction keyExtractor)
comparingLong(ToLongFunction keyExtractor)
comparingDouble(ToDoubleFunction keyExtractor)
nullsFirst(Comparator comparator)
nullsLast(Comparator comparator)

정렬에 사용되는 메서드는 많지만 가장 기본적인 메서드는 comparing()이다.

스트림의 요소가 Comparable을 구현한 경우, 매개변수 하나짜리를 사용하면 되고 아니면 추가적인 매개변수로 정렬기준(Comparator)를 따로 지정해주어야 한다.

비교 대상이 기본형인 경우, comparing()대신 comparingInt, comparingLong, comparingDouble을 사용하면 오토박싱과 언박싱 과정이 없기 때문에 더 효율적이다. 그리고 정렬 조건을 추가할 때에는 thenComparing()을 사용한다.

thenComparing(Comparator other)
thenComparing(Function keyExtractor)
thenComparing(Function keyExtractor, Comparator keyComp)

변환 - map()

스트림의 요소에 저장된 값 중에서 원하는 필드만 뽑아내거나 특정 형태로 변환해야 할 때가 있는데 그 때 사용하는 것이 바로 map()이다. 이 메서드의 선언부는 아래와 같고, T타입을 R타입으로 변환하는 함수를 지정해야한다.

Stream map(Function mapper)

예를들어 File스트림에서 파일의 이름만 뽑아서 출력하고 싶을 때, 아래와 같이 map()을 이용하면 쉽다.

Stream<File> fileStream = Stream.of(new File("Ex1.java"), new File("Ex1"),
 new File("Ex1.bak"), new File("Ex2.java"), new File("Ex1.txt"));
 
// map()으로 Stream을 Stream으로 변환
Stream filenameStream = fileStream.map(File::getName);
filenameStream.forEach(System.out::println);    // 스트림의 모든 파일의 이름을 출력

[실행결과]

Ex1.java

Ex1

Ex1.bak

Ex2.java

Ex1.txt

map()은 중간 연산으로 스트림을 반환하기 때문에 하나의 스트림에 여러 번 적용할 수도 있고, distinct를 뒤에 적용해서 중복을 제거할 수도 있다.

flatMap() - Stream<T[]>를 Stream<T>로 변환

스트림의 요소가 배열이거나 map()의 연산결과가 배열인 경우, 즉 스트림의 타입이 Stream<T[]>인 경우, Stream<T>로 다루는 것이 더 편리할 때가 있는데, 그럴 때는 map()대신 flatMap()을 사용하면 된다. 다음 예를 보자.

Stream strArrStrm = Stream.of(new String[] { "abc", "def", "ghi" }, new String[] { "ABc", "DEF", "GHI" });

이 때 각 요소의 문자열들을 합쳐서 문자열을 다루는 스트림, 즉 Stream<String>으로 만들려면 어떻게 해야할까? for문을 돌려서 할수도 있겠지만 flatMap을 사용하면 한 줄로 끝낼 수 있다.

String<String> strStrm = strArrStrm.flatMap(Arrays::stream);

또 다른 예제를 보면 여러 문장을 요소로 하는 스트림이 있을 때, 이 문장들을 split()으로 나눠서 요소가 단어인 스트림을 만들고 싶은 경우가 있을 것이다.

String[] lineArr = {
    "Belive or not It is true",
    "Do or do not There is no try"
};
 
Stream<String> lineStream = Arrays.stream(lineArr);
// Stream strArrStream = lineStream.map(1->Stream.of(line.split(" +")));
Stream<String[]> strArrStream = lineStream.flatMap(1->Stream.of(line.split(" +")));

이럴 때 map은 Stream<String[]>을 돌려주기 때문에 적절하지 않고 flatMap으로 하게되면 원하는 Stream<String>을 뽑아낼 수 있다.

드물지만, 스트림을 요소로 하는 스트림, 즉 스트림의 스트림을 하나의 스트림으로 합칠 때도 flatMap()을 사용한다.

Stream<String> strStrm = Stream.of("abc", "def", "jkl");
Stream<String> strStrm2 = Stream.of("ABC", "DEF", "JKL");
 
Stream<Stream<String>> strmStrm = Stream.of(strStrm, strStrm2);

이 때 Stream<Stream<String>>을 Stream<String>으로 변환하려면 다음과 같이 map()과 flatMap()을 함께 쓰면 된다.

Stream<String> strStream = strmStrm
.map(s -> s.toArray(String[]::new))    // Stream<Stream<String>> -> Stream<String[]>
.flatMap(Arrays::stream);    // Stream<String[]> -> Stream<String>

toArray()는 스트림을 배열로 변환해서 반환하는데 매개변수를 지정하지 않으면 Object[]을 반환하기 때문에 위와 같이 특정 타입을 사용하려면 해당 타입의 생성자를 지정해주어야한다.

4. 최종연산

리듀싱 - reduce()

스트림의 요소를 줄여나가면서 연산을 수행하고 최종결과를 반환한다. 그래서 매개변수의 타입이 BinaryOperator<T>이다. 처음 두 요소를 가지고 연산하고 그 결과를 다음요소와 연산한다. 이 과정에서 하나씩 요소를 소모하고 스트림의 모든 요소를 소모한 후에 그 결과를 반환한다.

Optional<T> reduce(BinaryOperator<T> accumulator)

여기서 Optional<T>이란 최종 연산의 결과 타입이 위와 같이 Optional인 경우가 있는데 이는 지네릭 클래스로 "T타입의 객체"를 감싸는 래퍼 클래스이다. 그래서 Optional타입의 객체에는 모든 타입의 참조변수를 담을 수 있다. (JDK1.8부터 추가됨)

public final class Optional<T> {
    private final T value;    // T 타입의 참조변수
    ...
}

최종 연산의 결과를 그냥 반환하는 것이 아니라 Optional객체에 담아서 반환하므로 반환된 결과가 null인지 매번 if문으로 체크하는 대신 Optional에 정의된 메서드를 활용해서 간단하게 처리할 수 있다. 이로 인해 널 체크를 위한 if문 없이도 NullPointerException이 발생하지 않는 보다 간결하고 안전한 코드를 작성하는 것이 가능해진다.

※ 참고 : Objects클래스에 isNull(), nonNull(), requireNonNull()과 같은 메서드가 있는 것도 널 체크를 위한 if문을 메서드 안에 넣어서 코드의 복잡도를 낮추기 위한 것.

다시 돌아와서 연산결과의 초기값을 갖는 reduce()도 있는데, 이 메서드들은 초기값과 스트림의 첫 번째 요소로 연산을 시작한다. 요소가 하나도 없는 경우 초기값이 반환되기 때문에 반환 타입이 Optional<T>가 아니라 T이다.

T reduce(T identity, Binaryoperator<T> accumulator)
U reduce(U identity, BiFunction<U,T,U> accumulator, Binaryoperator<U> combiner)

위의 두번째 메서드의 마지막 매개변수인 combiner는 병렬 스트림에 의해 처리된 결과를 합칠 때사용하기 위한 것이다.

int count = intStream.reduce(0, (a,b) -> a+1);    // count()
int sum = intStream.reduce(0, (a,b) -> a+b);    // sum()
int max = intStream.reduce(0, (a,b) -> a>b ? a:b);    // max()
int min = intStream.reduce(Integer.MIN_VALUE, (a,b) -> a

min, max는 초기값이 필요 없기 때문에 위에서 언급한 Optional<T>를 반환하는 메서드를 사용하는 것이 더 낫다. 단 intStream의 타입이 IntStream인 경우 OptionalInt를 반환한다.

T reduce(T identity, BinaryOperator<T> accumulator) {
    T a = identity;
 
    for (T b : stream)
        a = accumulator.apply(a, b);
 
    return a;
}

5. collect()

스트림의 최종 연산 중 가장 복잡하면서 유용하게 사용할 수 있는 것이 collect()이다.

스트림의 요소를 수집하기 위한 메서드로 수집 방법에 대해 정의되어 있어야 하는데 이 방법을 정의한 것이 바로 컬렉터(collector)이다.

컬렉터는 Collector인터페이스를 구현한 것으로, 직접 구현할 수도 있고 미리 작성된 것을 사용할 수도 있다. 

collect() 스트림의 최종연산, 매개변수로 컬렉터를 필요로 한다.

Collector 인터페이스, 컬렉터는 이 인터페이스를 구현해야 한다.

Collectors 클래스, static메서드로 미리 작성된 컬렉터를 제공한다.

collect()는 매개변수의 타입이 Collector인데 매개변수가 Collector를 구현한 클래스의 객체이어야 한다는 뜻이다. 매개변수로 넘어온 객체에 구현된 방법대로 스트림의 요소를 수집한다.

Object collect(Collector collector)
Object collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner)

아래의 collect()는 잘 사용되지 않지만 , Collector인터페이스를 구현하지 않고 간단히 람다식으로 수집할 때 사용하면 편리하다고 한다.

스트림을 컬렉션과 배열로 변환 - toList(), toSet(), toCollection(), toArray()

스트림의 모든 요소를 컬렉션에 수집하려면, Collectors클래스의 toList()와 같은 메서드를 사용하면 된다. List나 Set이 아닌 특정 컬렉션을 지정하려면, toCollection()에 해당 컬렉션의 생성자 참조를 매개변수로 넣어주면 된다.

List<String> names = stuStream.map(Student::getName).collect(Collectors.toList());
ArrayList<String> list = names.stream().collect(Collectors.toCollection(ArrayList::new));

Map을 사용하는 경우에는 키와 값의 쌍으로 저장해야 하므로 객체의 어떤 필드를 키로 사용할지, 값으로 사용할지를 지정해주어야한다.

리듀싱, 통계 - counting(), summmingInt(), averagingInt(), maxBy(), minBy(), reducing()

최종연산에 이미 존재하는 연산들을 collect()로 구현할 수 있다.

// int sum = intStream.reduce(0, (a,b) -> a+b);
 
int sum = intStream.boxed().collect(reducing(0, (a,b) -> a+b));

boxed()을 사용한 이유는 IntStream에는 매개변수가 3개짜리 collect()만 정의되어 있기 때문에 박싱을 통해 Stream<Integer>로 변환해주어야 매개변수 1개짜리 collect()를 사용할 수 있기 때문이다.

문자열 결합 - joining()

문자열 스트림의 모든 요소를 하나의 문자열로 연결해서 반환한다. 구분자를 지정해줄 수도 있고, 접두사와 접미사도 지정 가능하다. 대신 스트림의 요소가 String이나 StringBuffer처럼 ChareSequence의 자손인 경우만 가능하다. 따라서 스트림의 요소가 문자열이 아닌 경우 map()을 이용해서 스트림의 요소를 문자열로 변환해서 사용해야한다.

String studentNames = stuStream.map(Student::getName).collect(joining());
String studentNames = stuStream.map(Student::getName).collect(joining(","));
String studentNames = stuStream.map(Student::getName).collect(joining(",", "[", "]"));

map()없이 스트림에 바로 사용하게 되면 스트림의 요소에 toString()을 호출한 결과를 사용한다.

그룹화와 분할 - groupingBy(), partitioningBy()

여기부터 collect()의 유용함을 알 수 있는 부분이다. 그룹화는 스트림의 요소를 특정 기준으로 그룹화하는 것을 의미하고 분할은 스트림의 요소를 두 가지 지정된 조건에 일치하는 그룹과 일치하지 않는 그룹으로의 분할을 의미한다.

groupingBy()는 스트림의 요소를 Function으로, partitioningBy()는 Predicate로 분류한다.

Collector groupingBy(Function classifier)
Collector groupingBy(Function classifier, Collector downstream)
Collector groupingBy(Function classifier, Supplier mapFactory, Collector downstream)

Collector partitioningBy(Predicate predicate)
Collector partitioningBy(Predicate predicate, Collector downstream)

메서드 정의를 봤을 때 매개변수의 차이 말고는 동일하다는 것을 알 수 있다. 스트림을 두 개의 그룹으로 나눠야 한다면 당연히 partitioningBy()로 분할하는 것이 더 빠르다. 그 외에는 groupingBy()를 사용하면 된다. 두개 다 결과는 Map에 담겨 반환된다.

예시에 사용될 Student클래스

class Student {
    String name;    // 이름
    boolean isMale; // 성별
    int hak;        // 학년
    int ban;        // 반
    int score;        // 점수
    Student(String name, boolean isMale, int hak, int ban, int score) { 
        this.name    = name;
        this.isMale    = isMale;
        this.hak    = hak;
        this.ban    = ban;
        this.score  = score;
    }
    String    getName()  { return name;}
    boolean isMale()   { return isMale;}
    int        getHak()   { return hak;}
    int        getBan()   { return ban;}
    int        getScore() { return score;}
    public String toString() { 
        return String.format("[%s, %s, %d학년 %d반, %3d점]", name, isMale ? "남":"여", hak, ban, score); 
    }
    enum Level {    // 성적을 상, 중, 하 3단계로 분류
        HIGH, MID, LOW
    }
}    // class Student

그리고 스트림 stuStudent는 아래와 같은 요소들오 이루어져 있다고 하자.

Stream<Student> stuStream = Stream.of(
    new Student("나자바", true,  1, 1, 300),    
    new Student("김지미", false, 1, 1, 250),    
    new Student("김자바", true,  1, 1, 200),    
    new Student("이지미", false, 1, 2, 150),    
    new Student("남자바", true,  1, 2, 100),    
    new Student("안지미", false, 1, 2,  50),    
    new Student("황지미", false, 1, 3, 100),    
    new Student("강지미", false, 1, 3, 150),    
    new Student("이자바", true,  1, 3, 200),    
    new Student("나자바", true,  2, 1, 300),    
    new Student("김지미", false, 2, 1, 250),    
    new Student("김자바", true,  2, 1, 200),    
    new Student("이지미", false, 2, 2, 150),    
    new Student("남자바", true,  2, 2, 100),    
    new Student("안지미", false, 2, 2,  50),    
    new Student("황지미", false, 2, 3, 100),    
    new Student("강지미", false, 2, 3, 150),    
    new Student("이자바", true,  2, 3, 200)
);

partitioningBy()에 의한 분류

가장 기본적인 분할은 학생정보가 있다고 했을 때 학생들을 성별로 나누는 것이다.

Map<Boolean, List<Student>> stuBySex = stuStream.collect(partitioningBy(Student::isMale));
 
List<Student> maleStudent = stuBySex.get(true);
List<Student> femaleStudent = stuBySex.get(false);

counting()을 추가해서 각각 학생의 수를 구할수도 있다.

Map<Boolean, List<Student>> stuNumBySex = stuStream
                            .collect(partitioningBy(Student::isMale), counting());
 
System.out.println("남학생 수 : " + stuNumBySex.get(true));    // 8
System.out.println("여학생 수 : " + stuNumBySex.get(false));    // 10

groupingBy()에 의한 분류

partitioningBy()와 사용법은 같다. 반 별로 그룹지어 Map에 저장하는 방법을 보자.

Map<Boolean, List<Student>> stuByBan = stuStream
                            .collect(groupingBy(Student::getBan));

groupingBy()로 그룹화를 하면 기본적으로 List<T>에 담는다. 그래서 위의 문장은 toList()가 생략된 형태다.

Map<Boolean, List<Student>> stuByBan = stuStream
                            .collect(groupingBy(Student::getBan), toList());

toList() 대신 toSet()이나 toCollection(HashSet::new) 사용 가능하다. 단 Map의 지네릭타입도 그에 맞춰 바꾸어야 한다.

참조 : 자바의 정석 3rd