[JAVA] 스트림

Jae-Baek Song·2023년 1월 18일

모던자바인액션

목록 보기
3/11
post-thumbnail

저자: 라울-게이브리얼 우르마 , 마리오 푸스코 , 앨런 마이크로프트
도서명: 모던 자바 인 액션
출판사: 한빛미디어


스트림이란?

  • 자바 8 API에 새로 추가된 기능입니다.
  • 선언형(데이터를 처리하는 임시 구현 코드 대신 질의로 표현할 수 있다)으로 컬렉션 데이터를 처리할 수 있습니다.
  • filter, sorted, map, collect 같은 여러 빌딩 블록 연산을 연결해서 복잡한 데이터 처리 파이프라인을 만들어도 여전히 가독성과 명확성이 유지됩니다.
  • 멀티스레드 코드를 구현하지 않아도 데이터를 투명하게 병렬로 처리할 수 있습니다. 데이터 처리 과정을 병렬화하면서 스레드와 락을 걱정할 필요가 없습니다.

선언형(데이터를 처리하는 임시 구현 코드 대신 질의로 표현할 수 있다)으로 컬렉션 데이터를 처리할 수 있습니다.

// 기존의 코드
public static List<String> getLowCaloricDishesNamesInJava7(List<Dish> dishes) {
    List<Dish> lowCaloricDishes = new ArrayList<>();
    for (Dish d : dishes) {
      if (d.getCalories() < 400) {
        lowCaloricDishes.add(d);
      }
    }
    List<String> lowCaloricDishesName = new ArrayList<>();
    Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
      @Override
      public int compare(Dish d1, Dish d2) {
        return Integer.compare(d1.getCalories(), d2.getCalories());
      }
    });
    for (Dish d : lowCaloricDishes) {
      lowCaloricDishesName.add(d.getName());
    }
    return lowCaloricDishesName;
 }

위 코드에서 처럼 lowCaloricDishes 라는 '가비지 변수'를 사용했다.

// 스트림을 사용한 코드
public static List<String> getLowCaloricDishesNamesInJava8(List<Dish> dishes) {
    return dishes.stream()
        .filter(d -> d.getCalories() < 400)
        .sorted(comparing(Dish::getCalories))
        .map(Dish::getName)
        .collect(toList());
 }

즉, lowCaloricDishes 와 같은 컨테이너 역할만 하는 중간 변수가 필요없다.


멀티스레드 코드를 구현하지 않아도 데이터를 투명하게 병렬로 처리할 수 있습니다. 데이터 처리 과정을 병렬화하면서 스레드와 락을 걱정할 필요가 없습니다.

List<String> lowCaloricDishesName =
                menu.stream()
                        .filter(d -> d.getCalories() < 400)
                        .sorted(comparing(Dish::getCakirues))
                        .map(Dish::getName)
                        .collect(toList());

//병렬 처리 코드
List<String> lowCaloricDishesName =
                menu.parallelStream()
                        .filter(d -> d.getCalories() < 400)
                        .sorted(comparing(Dish::getCakirues))
                        .map(Dish::getName)
                        .collect(toList());

스트림 시작하기

스트림이란 '데이터 처리 연산을 지원하도록 소스에서 추출된 연속된 요소'

  • 연속된 요소
    Collection과 마찬가지로 Stream은 특정 요소 형식으로 이루어진 연속된 값 집합의 인터페이스
    Collection : 시간과 공간의 복잡성과 관련된 요소 저장 및 접근 연산
    Stream : filter, sorted, map 표현 계산식

  • 소스 : Stream은 데이터를 소비한다.

  • 파이프 라이닝 : 대부분의 스트림 연산은 스트림 연산끼리 연결해서 커다란 파이프라인을 구성할 수 있도록 스트림 자신을 반환한다. 덕분에 루프퓨전,쇼트서킷 같은 최적화도 얻을수 있다.

쇼트 서킷이란, 논리연산자 AND, OR 을 나타내기 위해 부호 &&, || 을 사용하는 것을 의미한다.

if ((5 < 1) && (x++ > y)) {
   y++; // 앞의 boolean 값이 false 일 때, && 뒤를 굳이 실행하지 않음
}

if ((5 > 1) || (a++ > b)) {
   b++; // 앞의 boolean 값이 false 일 때만 뒤를 실행한다. 
}

루프퓨전(loop fusion)이란 파이프라인에서 연속적으로 체이닝된 복수의 스트림 연산을 하나의 연산 과정으로 병합시키는 것을 뜻한다.

Lazy Evaluation, 연산을 불필요한 연산을 피하기 위해 연산을 지연시키는 것을 말합니다.

Stream.of(new Data(1), new Data(2), new Data(3))
.peek(Data::runOperationA) 
.peek(Data::runOperationB)
.forEach(Data::runOperationC); 

// 데이터 1의 작업A 
// 데이터 1의 작업B 
// 데이터 1의 작업C 
// 데이터 2의 작업A 
// 데이터 2의 작업B 
// 데이터 2의 작업C 
// 데이터 3의 작업A 
// 데이터 3의 작업B 
// 데이터 3의 작업C

복수의 스트림 연산이 하나로 병합되는 것을 최적화라고 볼 수 있는 이유는 기본적으로 개별 스트림 요소에 접근하는 횟수가 최소화되기 때문이다.
만일 루프병합이 일어나지 않는다면 개별 스트림 연산에서 매번 스트림의 요소를 처음부터 전부 다 순회해야 했을 것이다.
즉, 위의 예시를 생각해보면 3개의 스트림 요소는 원래 각각 3번씩, 총 9번 접근되어야 했다. 그러나 루프병합 과정 덕분에 각각 단 1번씩, 총 3번만 접근되었음을 알 수 있다.


컬렉션 스트림 차이

컬렉션

  • 컬렉션은 현재 자료구조가 포함하는 모든 값을 메모리에 저장하는 자료구조다. 따라서 컬렉션의 모든 요소는 컬렉션에 추가하기 전에 계산되어야한다.

스트림

  • 스트림은 요청할 때만 요소를 계산하는 고정된 자료구조이다. 스트림에 요소를 추가하거나 스트림에서 요소를 제거할 수 없다.
    사용자가 요청한 값만 스트림에서 추출한다.
  • 사용자가 데이터를 요청할 때에만 값을 계산한다.

스트림의 특징

1. 딱 한번만 탐색할 수 있다

List<String> names = Arrays.asList("Java8", "Lambdas", "In", "Action");
Stream<String> s = names.stream();
s.forEach(System.out::println); // 탐색된 스트림의 요소는 소비된다.

s.forEach(System.out::println); // 따라서 IllegalStateException 발생!

2. 내부반복과 외부반복

  • 외부 반복
    for-each 등 사용자가 직접 요소를 반복해야함.
List<String> names = new ArrayList();
for (Dish dish : menu) { // 명시적으로 순차 반복함 (외부 반복)
	names.add(dish.getName());
}
  • 내부 반복
    반복을 내부적으로 처리하고 결과 스트림값을 어딘가에 저장
menu.stream()
	.map(Dish::getName)
	.collect(toList());  // 내부 반복

내부 반복으로써 얻는 이점

  • 작업을 투명하게 병렬로 처리하거나, 더 최적화된 다양한 순서로 처리할 수 있다. (외부 반복으로 처리한다면 최적화를 달성하기 어려움)
  • 스트림 라이브러리의 내부 반복은 데이터 표현과 하드웨어를 활용한 병렬성 구현을 자동으로 선택함. (반면 외부반복에서는 병렬성을 스스로 관리해야함)

스트림 연산

스트림은 1개 이상의 중간 연산과 1개의 최종 연산으로 이루어져 있으며, Lazy한 특성을 갖는다.

  • 중간 연산: 파이프라인을 형성할 수 있는 스트림 연산(연결할 수 있는)
    • filter, map, limit, sorted, distinct ...
      다른 스트림을 반환한다. 이로써 여러 중간 연산을 연결해서 질의를 만들 수 있음.
    • 단말 연산을 스트림 파이프라인에 실행하기 전까지 아무 연산도 수행하지 않음 (lazy)
    • 스트림의 lazy한 특 때문에 최적화 효과를 얻을 수 있다. (쇼트 서킷 기법, 루프 퓨전)
  • 최종 연산: 스트림을 닫는 연산
    • collect, forEach, count ...
      스트림 파이프라인에서 결과를 도출한다.

https://bugoverdose.github.io/development/stream-lazy-evaluation/
https://willseungh0.tistory.com/24

0개의 댓글