[모던자바인액션] 스트림이란 무엇일까?

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

 

---

✔️ 스트림이란?

자바 8에 새롭게 들어온 기능 중, 가장 핵심적인 기능이라고 말해도 무방하다.

컬렉션 데이터의 반복을 도와주고, 멀티 스레드 코드 없이 병렬성을 구현할 수 있는 아주 유용한 친구이다.

또한, filter나 sorted, map, collect 같은 연산은 ‘high-level building block’이라고 하는데, 스트림을 마치 블록처럼 쌓고, 조립할 수 있다는 점이 큰 특징이다.

 

---

✔️ stream 메서드

🌱 스트림이란, 데이터 처리 연산을 위해 소스에서 추출된 연속된 요소이다.

1) 연속된 요소 

컬렉션은 데이터에 대한 자료구조였다면, 스트림은 이를 어떤 식으로 계산할지에 대해 다룬다.

두 가지 모두, 연속된 값 집합의 인터페이스를 제공한다.

 

2) 소스

데이터를 제공해주는 소스로부터 데이터를 소비한다.

스트림에게 제공한 리스트가 정렬되었다면 해당 스트림에서도 리스트는 정렬되어 있다.

 

3) 데이터 처리 연산

함수형 프로그래밍 언어의 연산 및 데이터베이스의 연산과 비슷한 연산을 제공하며, 순차/병렬 실행이 가능하다.

또한, 스트림은 자기 자신을 반환하기 때문에 체이닝이 가능하며, 반복자를 사용하지 않고 내부 반복을 통해 반복을 진행한다.

 

글로 보면 이해하기 어렵기 때문에, 코드로 살펴보자.

// course
public enum Course {
    BACKEND, FRONTEND, ANDROID
}

// crew
public class Crew {
    private final String name;
    private final String nickname;
    private final int age;
    private final Course course;

    public Crew(final String name, final String nickname, final int age, final Course course) {
        this.name = name;
        this.nickname = nickname;
        this.age = age;
        this.course = course;
    }
}

우리는 백엔드 과정인 크루를 최대 10명 뽑아 해당 크루의 이름을 가져올 것이다.

마치, DB에 쿼리를 질의를 하는 것과 같은 조건이다. 

스트림을 활용하면 다음과 같이 표현할 수 있다.

  List<String> backendCrews = crews.stream()
                // 람다의 인수(백엔드 크루)를 받아 특정 요소를 선택한다.
                .filter(crew -> crew.getCourse() == Course.BACKEND)
                // 람다를 이용하여 하나의 요소를 다른 요소로 반환한다.
                .map(Crew::getName)
                // 스트림 크기의 최대 사이즈를 지정한다.
                .limit(10)
                // 스트림을 다른 형식으로 변환한다. (여기서는 리스트로 변환)
                .collect(Collectors.toUnmodifiableList());

여기서 데이터 소스는, 크루 리스트를 의미하며, 각각의 크루에 대한 ‘연속된 요소’를 스트림에게 제공한다.

filter-map-limit-collect를 통한 데이터 처리 연산을 진행하며, filter-map-limit의 경우 반환형이 Stream이기 때문에 서로 파이프라인을 형성하게 된다. (체이닝이 가능해진다!)

 

---

✔️ 스트림 vs 컬렉션

두 가지 모두 연속된 요소의 값을 저장하는 자료구조의 인터페이스를 제공한다.

 

 

🌱 연산 측면에서의 차이

컬렉션은 해당 자료구조가 포함하는 모든 값을 메모리에 저장하기 때문에, 컬렉션에 추가나 삭제 등의 연산이 주어진다면 해당 요소들에 대한 정보를 모두 알고 있어야 한다. (ex. 만화책)

하지만, 스트림은 요청 시에만 해당 요소를 계산한다. (스트림 자체에 요소를 추가하거나 제거할 수가 없다)

또한, 생산자-소비자 관계로 인해서 사용자가 데이터를 요청할 때만 값을 생성하여 반환한다. (ex. 실시간으로 로드 중인 웹툰)

 

 

🌱 스트림은 한 번만 탐색이 가능하다

스트림은 단 한 번만 탐색이 가능하며, 탐색된 요소는 소비된다. 재탐색을 위해서는 다시 새로운 스트림을 만들어야 한다. 

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

Stream<String> backendCrews = crews.stream()
        .filter(crew -> crew.getCourse() == Course.BACKEND)
        .map(Crew::getName)
        .limit(10);

backendCrews.forEach(System.out::println);
backendCrews.forEach(System.out::println); // Error!

Intellij에서는 친절하게도 스트림을 재사용하려고 하려면 위와 같이 이미 소비되었다고 말을 해준다.

 

 

🌱 외부 반복과 내부 반복

또한, 반복에 대해서도 둘은 차이가 있다.

컬렉션은 사용자가 직접 반복을 해야 하지만 (외부 반복), 스트림은 반복을 내부적으로 알아서 처리하고 어딘가에 저장한다. (내부 반복)

 

외부 반복은 “명시적으로” 내부 요소들을 하나씩 접근하여, 가져와서 처리한다. 

즉, 크루 리스트가 있다면 크루A, 크루B, 크루C… 크루Z까지, 모든 크루들에 대해서 하나씩 가져와서 처리하는 것이다.

: 개발자가 명시적으로 반복문을 사용하여, 모든 요소를 하나씩 가져와서 처리.

// Iterator 사용
List<String> names = new ArrayList<>();
    Iterator<String> iterator = crews.iterator();
    while(iterator.hasNext()) {   
        Crew crew = iterator.next();
        names.add(dish.getName());
}

// for-each 사용
List<String> names = new ArrayList<>();
for (Crew crew : crews) {
    names.add(crew.getName());
}

위의 코드를 보자. 두 코드 모두 직접적으로 개발자가 반복문을 사용하여, 각 요소에 대해서 처리하고 있다.

 

그러나, 내부 반복이라면 크루를 가져오면서 다른 행위도 할 수 있고 (map, filter...),

순차적으로 가져오지 않고 크루A, 크루C… 이런 식으로 병렬적으로도 처리가 가능하다.

: 개발자는 단순히 처리 과정만 정의하고, 내부적으로 스트림이 요소를 반복하며 처리.

Stream<String> backendCrews = crews.stream()
        .map(Crew::getName)
        .limit(10);

위의 코드를 보자. map을 통해 크루들의 이름을 산출하고 있다.

여기서 개발자는 'map을 통해 크루들의 이름으로 매핑시키는 행위'만을 지정해주고 있으며, 스트림은 내부적으로 crew 리스트를 돌면서 매핑해주는 작업을 진행할 것이다. 별도의 반복자가 필요하지 않는 것이다.

 

---

✔️ 중간 연산과 최종 연산

스트림은 중간 연산과 최종 연산으로 나뉜다.

 

🌱 중간 연산

연산	반환 형식	연산의 인수	함수 디스크립터
filter	Stream<T>	Predicate<T>	T -> boolean
map	Stream<R>	Function<T, R>	T -> R
limit	Stream<T>
sorted	Stream<T>	Comparator<T>	(T, T) -> int
distinct	Stream<T>

 

🌱 최종 연산

연산	반환 형식	목적
forEach	void	스트림의 각 요소를 소비하면서 람다를 적용한다.
count	long (generic)	스트림의 요소 개수를 반환한다.
collect		스트림을 리듀스해서 리스트, 맵, 정수 형식의 컬렉션을 만든다.

 

중간 연산을 이용하면 반환형이 Stream이기 때문에 계속 체이닝을 통해서 연결할 수 있으며, 최종 연산을 실행하기 전까지는 아무 연산도 실행하지 않는다는 점이 특징이다. (책에서는 게으르다고 표현했다)

그리고, 최종 연산을 이용하면 스트림 파이프라인에서 결과를 도출하게 되며, Stream형이 아닌 List(Collectors.toUnmodifiableList()), void(forEach), long(count) 등 다른 결과로 반환할 수 있다.

 

List<Crew> crews = List.of(Crew.createByName("이름1", 20, Course.BACKEND),
                Crew.createByName("이름2", 21, Course.BACKEND),
                Crew.createByName("이름3", 22, Course.BACKEND),
                Crew.createByName("이름4", 23, Course.BACKEND));

예시를 들어보자. 크루에 대한 리스트를 정의해둔 것이다.

Stream<String> names =
        crews.stream()
                .filter(crew -> {
                    System.out.println("filter: " + crew.getName());
                    return crew.getAge() > 20;
                })
                .map(crew -> {
                    System.out.println("map: " + crew.getName());
                    return crew.getName();
                })
                .limit(2);

이때, 위와 같이 코드를 작성하게 되면 (중간 연산의 모음) 어떤 결과가 나올까?

놀랍게도 아무것도 출력되지 않는다. 

스트림은 최종 연산이 수행되기 전까지, 아무것도 하지 않는다는 게 이런 의미이다.

List<String> names =
        crews.stream()
                .filter(crew -> {
                    System.out.println("filter: " + crew.getName());
                    return crew.getAge() > 20;
                })
                .map(crew -> {
                    System.out.println("map: " + crew.getName());
                    return crew.getName();
                })
                .limit(2)
                .collect(toList());
                
 System.out.println("names = " + names);

반면에, collect를 통해 최종 연산을 수행하면 어떻게 될까?

실행해보면 다음과 같은 결과가 나온다.

최종 연산이 수행되었기 때문에 중간 연산이 실행되는 것을 볼 수 있다.

또한, limit를 통해 최대 2개까지만 가져오도록 설정을 했기 때문에, 처음부터 조건에 '이름4'는 들어가지 않은 것을 볼 수 있다.

이를 '쇼트 서킷' 연산이라고 할 수 있는데, 모든 요소를 처리하지 않고 주어진 크기의 스트림을 생성하여 그만큼만 처리하는 것이다.

 

스트림에 대해 다음과 같이 요약하며 마무리하고자 한다.

1. 질의를 수행할 데이터 소스
2. 스트림 파이프라인을 구성할 중간 연산 연결하기
3. 스트림 파이프라인을 실행하고, 결과를 만들기 위한 최종 연산을 통해 도출하기