[모던자바인액션] 스트림을 활용해보자! - 스트림 메서드

💬 모던 자바 인 액션 챕터 5을 읽고 정리한 글입니다.

 

---

✔️ 필터링

🌱 프리디케이트로 필터링하기

List<Crew> crews = new ArrayList<>();

List<Crew> backendCrews = crews.stream()
        // 람다의 인수(백엔드 크루)를 받아 특정 요소를 선택한다.
        .filter(crew -> crew.getCourse() == Course.BACKEND)
        .collect(Collectors.toUnmodifiableList());

지난 챕터에서 사용했던 예제이다.

여기서 filter 메서드는 Predicate<T>를 인수로 받아서, 해당 프리디케이트와 일치하는 모든 요소를 포함하는 스트림을 반환한다.

 

 

🌱 고유 요소 필터링

distinct 메서드를 사용하면 중복을 제거한 요소로 이루어진 스트림을 반환한다.

이때, 중복 여부는 hashCode와 equals를 통해 결정된다. (재정의 필요!)

List<Crew> crews = new ArrayList<>();
List<Crew> backendCrews = crews.stream()
        .filter(crew -> crew.getCourse() == Course.BACKEND)
        .distinct()
        .collect(Collectors.toUnmodifiableList());

 

---

✔️ 스트림 슬라이싱

🌱 takeWhile

자바9에서는 takeWhile, dropWhile이라는 것을 통해서 스트림의 요소를 효과적으로 선택할 수 있도록 지원한다.

List<Crew> crews = new ArrayList<>();
List<Crew> backendCrews = crews.stream()
        .filter(crew -> crew.getAge() <= 25)
        .collect(Collectors.toUnmodifiableList());

우선, 앞서 말한 filter를 사용하게 되면 전체 스트림을 반복하면서 각각의 요소에 Predicate<T>를 적용한다.

그러나, 만약 대상 리스트가 정렬되어 있다면 어떨까?

predicate를 만족하는 지점까지 확인하고 (여기서는 나이가 25살 이하) 그 뒤로는 보지 않아도 되는 것이다.

 

이러한 연산을 takeWhile을 활용하면 쉽게 진행할 수 있다.

List<Crew> crews = new ArrayList<>();
List<Crew> backendCrews = crews.stream()
        .takeWhile(crew -> crew.getAge() <= 25)
        .collect(Collectors.toUnmodifiableList());

takeWhile은 조건에 대해 참이 아닐 경우 바로 거기서 멈추게 된다.

즉, 해당 리스트에 나이에 대해 정렬되어 있을 때 사용해야 한다는 점을 기억해야 한다.

 

🌱 dropWhile

만약, takeWhile로 선택되지 않은 다른 요소들에 선택하기 위해서는 dropWhile을 사용하면 된다.

List<Crew> crews = new ArrayList<>();
List<Crew> backendCrews = crews.stream()
        .dropWhile(crew -> crew.getAge() <= 25)
        .collect(Collectors.toUnmodifiableList());

dropWhile을 사용하면 takeWhile과 반대로 수행한다.

dropWhile은 처음으로 거짓이 되는 지점까지 발견된 요소들을 버리고, 남은 요소들을 반환한다.

 

---

✔️ 스트림 축소

🌱 limit

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

이는, 스트림이 정렬되어 있을 때 최대 요소 n개를 반환한다.

List<Crew> crews = new ArrayList<>();
List<String> backendCrews = crews.stream()
        .filter(crew -> crew.getCourse() == Course.BACKEND)
        .limit(10)
        .collect(Collectors.toUnmodifiableList());

물론, 정렬되지 않은 상태에서도 limit을 사용할 수 있으며, 이러면 결과 역시 정렬되지 않은 상태로 반환한다.

 

---

✔️ 요소 건너뛰기

🌱 skip

처음 요소 n개를 제외한 스트림을 반환하는 skip(n) 메서드가 존재한다.

만약, n개 이하의 요소가 존재한다면 빈 스트림이 반환되기 때문에 스트림은 주어진 값보다 더 큰 사이즈를 가지고 있어야 한다.

List<Crew> crews = new ArrayList<>();
List<Crew> backendCrews = crews.stream()
        .filter(crew -> crew.getCourse() == Course.BACKEND)
        .skip(3)
        .collect(Collectors.toUnmodifiableList());

 

 

---

✔️ 매핑 

🌱 map

스트림에서는 map() 메서드를 통해 함수를 인수로 받을 수 있다.

받은 함수는 각 요소에 적용되며, 적용된 결과가 새로운 요소로 매핑된다.

List<Crew> crews = new ArrayList<>();
List<String> backendCrews = crews.stream()
        .filter(crew -> crew.getCourse() == Course.BACKEND)
        .map(Crew::getName)
        .collect(Collectors.toUnmodifiableList())

위 코드에서 map을 통해 Crew 타입을 String 형태로 반환하도록 만들었다.

 

 

🌱 flatMap

매핑 기능 중에서, flatMap()이라는 특별한 기능이 존재한다.

이는 스트림 각각의 요소를 다른 스트림으로 만든 다음에, 모든 스트림을 하나의 스트림으로 연결한다.

String[] words = {"Hello", "Wootechco"};
List<String> splitedWords =
        // 배열의 각 요소에 대해서 stream 순회	
        Arrays.stream(words)
                // 각 요소를 분해하여 매핑 (H,e,l,l,o / W,o,o,t,e,c,h,c,o)
                .map(word -> word.split(""))
                // 생성된 스트림을 하나의 스트림으로 평면화 진행, (word -> Arrays.stream(word))와 동일한 의미이다.
                .flatMap(Arrays::stream)
                // 리스트로 모으기
                .collect(Collectors.toList());

// [H, e, l, l, o, W, o, o, t, e, c, h, c, o]
System.out.println(splitedWords);

Intellij에서 스트림의 각 반환값에 대해 추론한 결과를 보자.

word.split(””) 했을 때 “Hello”, “wootechco”라는 각 문자열에 대하여 split을 진행한 결과로 String[]을 가진 스트림을 반환하게 되고, 해당 스트림에 대해 flatMap을 사용하여 Stream<String>을 반환하는 것을 볼 수 있다. (String[] -> String으로 평면화)

 

---

✔️ 검색과 매칭

특정 속성이 데이터 집합에 존재하는지에 대해 Stream API를 활용하면 쉽게 처리할 수 있다.

 

 

🌱 anyMatch

boolean isBackendCrew = crews.stream()
       .anyMatch(crew -> crew.getCourse() == Course.BACKEND);

적어도 하나의 요소와 일치하는지 확인한다.

 

 

🌱 allMatch

boolean isBackendCrew = crews.stream()
       .allMatch(crew -> crew.getCourse() == Course.BACKEND);

모든 요소와 일치하는지 확인한다.

 

 

🌱 noneMatch

boolean isBackendCrew = crews.stream()
       .noneMatch(crew -> crew.getCourse() == Course.BACKEND);

모든 요소와 일치하지 않는지 확인한다.

 

위 3가지 연산은 모두 ‘쇼트서킷 기법’을 사용하게 되는데, 이는 전체 스트림을 처리하지 않더라도 결과를 도중에 반환하는 것을 의미한다.

예를 들어, 자바에서 if (a && b)라는 조건문이 있을 때, a가 거짓이면 그 뒤의 조건식은 보지 않고 바로 전체에 대해 거짓이라고 판단하게 된다. 이런 상황을 쇼트서킷이라고 하며, 모든 스트림의 요소에 대해서 판단하지 않고, 원하는 결과를 찾았으면 바로 결과를 반환하는 것을 의미한다. (limit 역시 쇼트서킷 연산이다)

 

 

🌱 findAny

Optional<Crew> backendCrew = crews.stream()
                .filter(crew -> crew.getCourse() == Course.BACKEND)
                .findAny()

스트림에서 임의의 요소를 반환한다.

filter + findAny를 사용하게 되면, 해당 조건과 일치하는 임의의 요소를 리턴한다.

이때, 요소가 존재하지 않을 수 있기 때문에 Optional<T>을 사용할 수 있다.

Optional을 활용하면 값이 존재하거나, 혹은 존재하지 않음을 명시적으로 처리할 수 있다.

여기서 체이닝을 통해 ifPresent나 isPresent를 통해 값이 존재하지 않는 경우에 대해 처리할 수 있다. (추후 챕터를 진행하며 나온다!)

boolean isPresent = crews.stream()
                .filter(crew -> crew.getCourse() == Course.BACKEND)
                .findAny()
                .isPresent();

        // 존재한다면 별도의 로직 실행
        crews.stream()
                .filter(crew -> crew.getCourse() == Course.BACKEND)
                .findAny()
                .ifPresent(crew -> System.out.println(crew.getName()));

        // 값이 존재하면 가져오고, 아니라면 NoSuchElementException
        Crew backendCrew = crews.stream()
                .filter(crew -> crew.getCourse() == Course.BACKEND)
                .findAny()
                .get();

        // 값이 있으면 반환하고, 아니라면 설정한 기본값 반환
        Crew defaultCrew = crews.stream()
                .filter(crew -> crew.getCourse() == Course.BACKEND)
                .findAny()
                .orElse(new Crew());

대충 위의 예시처럼 값이 존재할 때, 혹은 존재하지 않을 때 별도의 조건을 주어서 조금 더 용이하게 처리할 수 있게 해준다.

 

 

🌱 findFirst

만약, 스트림 내부의 아이템 순서가 정해져 있다면 어떨까? findFirst()를 활용하면 일치하는 요소 중 가장 첫 번째 값을 반환한다.

Optional<Crew> backendCrew = crews.stream()
                .filter(crew -> crew.getCourse() == Course.BACKEND)
                .findFirst();

그렇다면, 이러한 의문이 들 것이다. findFirst와 findAny 모두 동일한 Optional<Crew>를 반환하는데, 무슨 차이가 있을까?

 

바로, 병렬성에서 차이가 있다.

병렬 실행에서는 첫 번째 요소가 어떤 것인지 알기가 어렵기 때문에, 요소의 반환 순서가 상관없다면 병렬 스트림에서는 (parallelStream) findAny()를 사용하는 것이 좋다.

// Stream.java
@Override
public final Optional<P_OUT> findFirst() {
    return evaluate(FindOps.makeRef(true));
}

@Override
public final Optional<P_OUT> findAny() {
    return evaluate(FindOps.makeRef(false));
}

실제로 둘의 내부 구현을 보면, 인자로 mustFindFirst라는 boolean값을 받는 것을 볼 수 있는데, 내부적으로 어떠한 로직을 통해서 첫 번째 값을 반환하게 된다.

Params: mustFindFirst – whether the TerminalOp must produce the first element in the encounter order

주석에 적힌 설명을 보면, 주어진 순서에서 가장 처음으로 발견된 값을 리턴하거나, 아니면 그냥 아무 요소나 리턴함을 알 수 있다.

 

---

✔️ 리듀싱

스트림 요소를 조합하여 더 복잡한 질의를 표현하기 위해서 리듀싱 연산을 사용할 수 있다.

이는 모든 스트림 요소를 처리하여 하나의 값으로 도출하는 것을 의미하며, 함수형 프로그래밍에서는 ‘폴드’라고도 말한다.

리스트에 존재하는 모든 숫자를 더한다고 가정해보자.

// before
int sum = 0;
for(int number : numbers) {
    sum += number;
}

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

// 메서드 참조
sum = numbers.stream().reduce(0, Integer::sum);

for-each 대신에 reduce를 사용하면, 코드가 훨씬 간결해지는 것을 볼 수 있다.

 

 

🌱 reduce 

T reduce(T identity, BinaryOperator<T> accumulator);

Stream 인터페이스에 정의된 reduce는 다음과 같이 구성된다.

첫 번째 인자로는 초깃값을, 두 번째 인자로는 두 개의 요소를 조합하여 새로운 값을 만들도록 BinaryOperator<T>를 사용한다. (이때, 두 요소는 모두 같은 타입이어야 한다)

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

우리의 코드에서는 초기값으로 0을, 그리고 새로운 값을 만들기 위한 오퍼레이터는 (a, b) → a + b를 사용하였다.

덧셈이 아닌 곱셈, 뺄셈 등으로도 자유롭게 응용이 가능하다.

 

reduce는 어떤 방식으로 스트림의 모든 숫자를 더하게 될까?

초기값으로부터, 스트림의 각 요소를 하나씩 소비하며 그 결과값을 그 다음 연산을 위한 누적값으로 사용한다.

그리고, 해당 누적값과 그 다음 요소를 함께 람다식에 조합하여 계속 계산해나가는 형식이다.

 

참고로, 초기값을 선언하지 않아도 된다. 단, 이 경우는 Optional 객체를 반환한다.

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

스트림에 아무 요소도 존재하지 않을 경우, 초기값도 없다면 합계를 반환할 수 없기 때문에 Optional을 통해 null에 대한 존재 여부를 나타낸다.

 

또한, reduce를 이용하면 최댓값과 최솟값도 쉽게 구할 수 있다.

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

Optional<Integer> max = numbers.stream().reduce(Integer::max);
Optional<Integer> min = numbers.stream().reduce(Integer::min);

 

 

🌱 reduce의 장점

이러한 reduce를 사용하면 뭐가 좋을까?

우선, 내부 반복으로 인해 반복하는 로직이 추상화되면서, reduce 자체를 내부적으로 병렬로 실행할 수 있게 된다는 것이다.

위에서부터 계속 보았던 합을 구하는 reduce를 생각해보자.

우리가 외부 반복을 통해 요소의 합을 구한다면 다음과 같이 코드를 작성할 것이다.

List<Integer> numbers = List.of(1, 2, 3, 4);
int sum = 0;
for (Integer number: numbers) {
	sum += number;
}

여기서 공유 변수인 sum이 있기 때문에, 우리가 위 로직을 병렬적으로 처리하고 싶다면 공유 변수에 대한 동기화 처리를 해줘야 한다.

하지만, stream을 사용하게 된다면 단순히 parallelStream()을 사용하는 것만으로도 병렬성을 쉽게 얻을 수 있게 된다.

또한, reduce를 사용하게 된다면 공유 변수가 없기 때문에 위와 같이 합을 구하더라도 병렬로 실행이 가능하게 된다.

(이에 대해서는 개별로 포스팅을 올려보도록 하겠다 :D)

 

 

🌱 스트림의 상태

map, filter 등은 입력 스트림에서 요소를 받아 출력 스트림으로 보내기 때문에, 내부적으로 상태를 가지고 있지 않다.

요소가 처리될 때마다 바로바로 처리 결과를 출력하기 때문에, 출력 스트림의 요소 개수와 입력 스트림의 요소 개수가 동일하게 유지된다.

 

하지만, sort, distinct 등은 요소를 정렬하거나 중복을 제거하기 위해서 과거의 상태를 가지고 있어야 한다.

이런 경우 ‘상태가 있는 스트림’이라고 하며, 상태가 있는 스트림 모든 요소가 버퍼에 사전에 추가가 되어 있어야 하기 때문에, 스트림 데이터의 크기가 크면 문제가 발생할 수 있다.

 

또한, reduce, sum 같은 연산은 내부적으로 결과를 누적해야 하기 때문에 내부 상태의 크기는 한정되어 (bound) 있어야 한다.

우리는 위 코드에서 Integer::max 등을 활용해서 내부의 값이 최대 Integer 범위 내의 값임을 한정한 셈이다.

 

그래서 상태가 있는 스트림은 상태가 없는 스트림보다 처리 시간이 오래 걸릴 수 있으며, 내부 크기 제약이 필요하다.

이러한 점을 잘 고려하여 코드를 작성해야 한다.

---

✔️ 숫자형 스트림

int ages = crews.stream() 
                .map(Crew::getAge)                      
                .reduce(0, Integer::sum);

위 코드에서는 Integer::sum이라는 메서드 참조 코드로 인해서 int → Integer로의 박싱 비용이 소요된다.

💡 박싱은 객체를 생성하고 초기화하는 과정이 필요하기 때문에, 이 과정에서 메모리 할당, 생성자 호출 등의 비용이 발생한다.

 

이를 해결하기 위해, 기본형 특화 스트림을 활용해보자.

기본 스트림에서 기본형 특화 스트림으로 변환하기 위해서는 각 타입에 맞춰 mapToInt, mapToDouble, mapToLong 3가지 메서드를 활용할 수 있다.

int ages = crews.stream()
                .mapToInt(Crew::getAge)
                .sum();

위 예제에서는 mapToInt를 활용해서 IntStream을 반환하여 (기본형 특화 스트림) 해당 스트림에서 제공하는 sum 메서드를 활용하여 합을 계산하였다. 이때, 만약 IntStream이 비어있으면 sum은 기본값인 0을 반환하게 되며, sum 외에도 다양한 유틸리티 메서드를 제공한다.

 

기본형 특화 스트림에서 기본 스트림으로 복원하기 위해서는, boxed 메서드를 활용하면 된다.

Stream<Integer> stream = crews.stream()
                .mapToInt(Crew::getAge)
                .boxed();

 

기본형 특화 스트림에서 max를 사용할 때, 값이 없는 경우와 최댓값이 0인 경우 모두 0을 도출한다.

이때, 둘을 어떻게 구별할 수 있을까? 이때는 Optional을 활용하자.

OptionalInt ages = crews.stream()
        .mapToInt(Crew::getAge)
        .max();

// 최댓값이 없는 상황에 대해 기본값 정의
int ages = crews.stream()
        .mapToInt(Crew::getAge)
        .max()
        .orElse(10);

이렇게 하면 IntStream의 최댓값을 확실하게 체크할 수 있으며, 최댓값이 없는 상황에 대해서도 명시적으로 정의가 가능하다.

 

특정 범위의 숫자를 사용해야 할 때는, range를 활용해보자.

// 시작-종료값이 결과에 포함하지 않음
IntStream range = IntStream.range(1, 100);

// 시작-종료값이 결과에 포함됨
IntStream range = IntStream.rangeClosed(1, 100);

 

 

---

✔️ 스트림 생성하기

🌱 값 → 스트림 : of

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

stream.map(String::toUpperCase)
		.forEach(System.out::println); // MODERN ,JAVA ,IN ,ACTION

// 스트림 비우기
stream.empty();

각각의 값들에 대해서 스트림으로 생성할 수 있다. 

 

 

🌱 null이 될 수 있는 개체를 스트림으로 생성 : ofNullable

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

// After
// ofNullable을 사용하면 생성할 수 있다.
Stream<String> homeValueStream
	= Stream.ofNullable(System.getProperty("home"));

기존 코드에서는 직접 null을 체크해준 다음에 null이면 빈 스트림, 아니면 값을 넣은 스트림을 해줬어야 했다.

ofNullable을 활용하면 알아서 기존 코드에 대한 부분을 내부적으로 처리해준다.

public static<T> Stream<T> ofNullable(T t) {
    return t == null ? Stream.empty()
                     : StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
}

이런 식으로!

 

 

🌱 배열 → 스트림 : Arrays.stream

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

이때, int[] 같은 primitive type에 대해서는 기본형 특화 스트림을 반환한다.

 

 

🌱 파일 → 스트림 (nio API)

long uniqueWords = 0;

// try-with-resources
try(Stream<String> lines =
            Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) {

    // split을 호출하여 각 단어 분리
    // flatMap을 통해서 하나로 평면화
    uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" ")))
            .distinct()
            .count();
} catch(IOException e){
}

 

🌱 함수 → 무한 스트림  : iterate

// UnaryOperator<T>
Stream.iterate(0, n -> n + 2)
        // 무한으로 값을 생성할 수 있기 때문에 (언바운드 스트림) 개수 제한
        .limit(10)
        .forEach(System.out::println); // 0, 2, 4...

무한 스트림은 크기가 고정되지 않은 스트림을 의미한다. 보통 limit으로 스트림의 최대 사이즈를 제한하는 것이 일반적이다.

만약 제한하지 않게 된다면 중간 연산은 스트림의 요소를 소비하지 않기 때문에, 아무 결과도 계산되지 않는다.

또한, 무한이기 때문에 정렬하거나 reduce 연산을 수행할 수 없다.

public static<T> Stream<T> iterate(T seed,
            Predicate<? super T> hasNext,
            UnaryOperator<T> next) {
        ...
}

iterate 메서드의 내부적으로 Predicate를 지원하기 때문에, 특정 조건에 맞는 숫자를 생성하는 것도 가능하다.

 

// 100 이내의 값을 0부터 시작해서 4씩 증가하여 출력
IntStream.iterate(0, n -> n < 100, n -> n + 4)
        .forEach(System.out::println);

// 혹은, takeWhile을 사용할 수 있다.
// filter는 언제 중단해야 할지 알 수 없기 때문에 filter로는 대체되지 않는다.
IntStream.iterate(0, n -> n + 4)
        .takeWhile(n -> n < 100)
        .forEach(System.out::println);

위에 작성한 것처럼, 특정 조건을 줄 때 filter를 사용할 수 없다. 

쇼트 서킷 기법을 사용하는 takeWhile 기능을 통해서 종단 지점이 확실하도록 조건을 주어야 한다.

 

 

🌱 함수 → 무한 스트림 : generate

generate는 iterate와 다르게, 생산된 값에 대한 연속성을 보장하지 않는다.

// 0~1 사이의 임의의 숫자 5개 생성
Stream.generate(Math::random)
         .limit(5)
         .forEach(System.out::println);

generate 내부에서는 Supplier를 받는다. 

마찬가지로, 박싱 연산을 피하기 위해서는 기본형 특화 스트림을 사용하면 된다.

// 0~1 사이의 임의의 숫자 5개 생성
DoubleStream.generate(Math::random)
            .limit(5)
            .forEach(System.out::println);

 

앞서 말했던 것처럼 generate는 인자로 supplier를 받는다.

supplier를 통해서 어떠한 조작을 통해 스트림에 존재하는 다음 값을 생성할 때 상태를 변경할 수도 있게 된다.

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

교재에서 제시된 피보나치 수열을 위한 Supplier다.

Supplier 내부에서 'previous', 'current' 같은 변수를 선언한 다음에, 다음 요소들을 계산할 때 해당 변수의 값을 사용하는 것을 볼 수 있다. 이렇게 되면, 객체가 생성되었을 때 기존의 요소가 영향을 주기 때문에 가변 상태 객체가 된다.

 

만약, 병렬로 처리하게 된다면 previous와 current의 값이 순차적으로 증가하는 형태가 아니게 될 것이다.

그래서 병렬 상태에서는 위의 코드처럼 상태를 가지고 있게 만드는 것이 아니라, 어떠한 상태에도 의존하지 않도록 코드를 작성해야 한다.

반면에 iterate의 경우 상태에 대한 조작은 불가능하기 때문에 비교적 병렬 실행에 안전하다고 볼 수 있다. (불변성 보장)

 

---

이번 챕터의 내용을 간략하게 정리해보자.

- filter, distinct, takeWhile, dropWhile, skip, limit으로 스트림을 필터링하거나 자를 수 있다.
- map, flatMap으로 스트림의 요소를 추출하거나 변환할 수 있다.
- findFirst, findAny로 스트림의 요소를 검색할 수 있다.
- allMatch, noneMatch, anyMatch로 프리디케이트와 일치하는 요소를 검색할 수 있다.
- reduce를 통해 모든 요소를 반복적으로 조합하여 값을 도출할 수 있다.
- iterate, generate로 무한 스트림을 만들 수 있다.
- 박싱 비용을 줄이기 위한 기본형 특화 스트림 (IntStream, DoubleStream, LongStream)을 활용할 수 있다.

[상태 없는 연산] filter, map
[상태 있는 연산] reduced, sorted, distinct