[모던 자바 인 액션] 스트림 정리 1- 스트림 소개

 

0. 컬렉션

 

 

 

컬렉션으로 데이터를 그룹화하고 처리하는 특징을 살려 sql 질의와 같이 비슷하게 만들 수 있다.

→ 선언형

 

이와 같이 많은 요소를 포함하는 커다란 컬렉션은 병렬 처리 코드가 필요하다.

⇒ 스트림이 해결책!

1. 스트림 소개

1. 자바 8에서 추가된 기능

2. 선언형으로 데이터 처리 가능

3. 멀티스레드 코드 구현 없이 병렬로 투명하게 처리 가능
   1. 데이터 처리 과정을 병렬화하면서 스레드와 락을 걱정할 필요가 없음

 

• 스트림 적용 전의 자바 7코드

  List<Dish> lowCaloricDishes = new ArrayList<>();
  
  for(Dish dish: menu) { // 누적자로 요소 필터링
  		if(dish.getCalories() < 400) {
  			lowCaloricDishes.add(dish);
  		}
  }
  // 익명 클래스로 요리 정렬
  Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
  	public int compare(Dish dish1, Dish dish2) {
  		return Integer.compare(dish.getCalories(), dish2.getCalories());
  	}
  });
  
  List<String> lowCaloricDishesName = new ArrayList<>();
  
  for(Dish dish: lowCaloricDishes) {
  		// 정렬된 리스트를 처리하면서 요리 이름 선택
  		lowCaloricDishesName.add(dish.getName());
  }

   
• lowCaloricDishes → 가비지 변수 사용

• 스트림 적용 후의 자바 8 코드

  List<String> lowCaloricDishesName = 
  										menu.stream()
  										.filter(d -> d.getCalories() < 400)
  										.sorted(comparing(Dish::getCalories))										
                                          .map(Dish::getName)
                                          .collect(toList());
  
  // stream -> parallelStream()을 이용하여 멀티코어 아키텍처에서 병렬로 실행
  List<String> lowCaloricDishesName = 
  										menu.parallelStream()
  										.filter(d -> d.getCalories() < 400)
  										.sorted(comparing(Dish::getCalories))
  										.map(Dish::getName)
  										.collect(toList());

   

 

딱 봐도 코드양부터 차이가 난다.

 

스트림의 특징

1. 선언형 : 더 간결하고 가독성이 좋아진다.

⇒ 기존에는 요구사항이 변경되면 기존 코드를 복사 붙여넣기를 해야했지만, 람다표현식으로 필터링하는 코드를 변경하기만 하면 간단하게 요구사항에 맞출 수가 있게 되었다.

 

2. 조립할 수 있음 : 유연성이 좋아진다.

3. 병렬화 : 성능이 좋아진다.

 

각각의 filter, sorted, map 과 같은 “빌딩 블록” 연산 을 연결해서 복잡한 데이터 처리 파이프 라인을 만들 수가 있다.

영어로 building block은 벽돌 혹은 집 짓는 블록을 뜻하는데, building blocks처럼 복수로 쓰이면 “기본 (구성)요소”라는 뜻이 있다.

이렇게 생각하면 뽝 이해가 된다.

자바의 기본 구성요소가 무엇인가? 클래스와 메서드 그리고 여러 필드등 일 것이다. 따라서 여기서 빌딩 블록은 자바의 클래스 단위를 말한다.

책에서는 filter와 같은 연산들은(sorted, map, collect) 고수준 빌딩 블록으로 이루어져 있다고 한다.

바꿔서 말하자면, 고수준 구성요소라 할 수 있겠다.

 

 

 

고수준 구성 요소쯤은 이미 알고 있는 개념이다.

객체 지향에서 인터페이스에 의존해야 캡슐화가 깨지지 않음을 배우고 왔다. 여기서 이 추상화된 인터페이스가 고수준 구성 요소인 것이다.

자 다시 책으로 돌아가서 내용을 살펴보면, 고수준 빌딩 블록으로 이루어져 있기 때문에 특정 스레딩 모델에 제한되지 않고 자유롭게 어떤 상황에서든 사용할 수 있다고 한다.

⇒ 당연하다. 얘넨 어디에 의존적인 애들이 아니니까 제한되지 않는 것이다.

코드를 까보면 이미 Stream 부터가 인터페이스이고, 인터페이스 안의 메서드는 자연스럽게 추상 메서드이다.

filter 자체만 보면 딱히 뭐 멀티 코어 환경에 적합하게 짜여 있는 듯한 느낌은 없는데,

그리고 Collection 코드를 확인해보면

default Stream<E> stream() {
    return StreamSupport.stream(spliterator(), false);
}
default Stream<E> parallelStream() {
    return StreamSupport.stream(spliterator(), true);
}

이렇게 내부적으로 StreamSupport클래스에서 Boolean값으로 구별해서 멀티스레드에 맞게 사용할 수 있도록 되어있다.

 

• 예제 코드

  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, 400, Dish.Type.FISH),
      new Dish("salmon", false, 450, Dish.Type.FISH)
  );

  • 불변형 코드 → Setter 없음

  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;
      }
  
      public enum Type { MEAT, FISH, OTHER }
  }

 

 

2. 스트림 시작하기

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

 

1. 연속된 요소
   1. 스트림도 컬렉션처럼 특정 요소 형식으로 이루어진 연속된 값 집합의 인터페이스를 제공한다.

   public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
   	  Objects.requireNonNull(spliterator);
   	  return new ReferencePipeline.Head<>(spliterator,
   	                                      StreamOpFlag.fromCharacteristics(spliterator),
   	                                      parallel);
   }

2. 소스
   1. 스트림은 컬렉션, 배열, I/O 자원 등 데이터 제공 소스로부터 데이터를 소비한다.
   2. ReferencePipeline 코드 참고

   @Override
   public void forEach(Consumer<? super E_OUT> action) {
       if (!isParallel()) {
           sourceStageSpliterator().forEachRemaining(action);
       }
       else {
           super.forEach(action);
       }
   }
   
   @Override
   public void forEachOrdered(Consumer<? super E_OUT> action) {
       if (!isParallel()) {
           sourceStageSpliterator().forEachRemaining(action);
       }
       else {
           super.forEachOrdered(action);
       }
   }

   보다시피 정렬된거는 정렬된 그대로 유지해서 처리한다.

3. 데이터 처리 연산
   1. 스트림은 함수형 프로그래밍 언어에서 일반적으로 지원하는 연산 + 데이터베이스와 비슷한 연산 모두 제공한다.
   → limit, peek, sorted, distinct 등등 Stream코드 보면 다 있다.

4. 파이프라이닝
   1. 앞서 스트림의 특징에 조립할 수 있는 점이 있었는데, 스트림은 연산끼리 연결해서 커다란 파이프라인을 구성할 수 있도록 스트림 자신을 반환한다.→ 이건 게으름(laziness), 쇼트 서킷 (short-circuiting)과 같은 최적화도 얻을 수 있다는데, 5장에서 알아보자. 지금은 모름
   2. → 연산 파이프라인은 데이터 소스에 적용하는 DB질의와 비슷하게 생겼다.

5. 내부 반복
   1. 반복자를 이용해서 명시적으로 반복하는 컬렉션과는 달리 스트림은 내부 반복을 지원한다.

 

예제 살펴보기

List<String> threeHighCaloricDishNames = 
			menu.stream()            //메뉴(요리 리스트)에서 스트림 얻기
					.filter(dish -> dish.getCalories()> 300) // 파이프 연산 만들기, 첫 번째로 고칼로리 요리를 필터링
					.map(Dish::getName)     //요리명 추출
					.limit(3)               //선착순 3개로 제한
					.collect(toList());     //결과를 다른 리스트로 저장

System.out.println(threeHighCaloricDishNames); //[pork, beef, chicken]

• 데이터 소스 : 요리 리스트(메뉴) → 연속된 요소로서 스트림이 제공됨

• 데이터 처리 연산 : filter, map, limit, collect로 이어짐

• collect를 제외한 연산은 서로 파이프라인 형성을 위해 스트림 자신을 반환

 

3. 스트림과 컬렉션

한마디로 스트림은 지연 로딩이다.

그림처럼 스트리밍을 처리할 때 애초에 데이터 자체가 실시간으로 생겨나는 거기 때문에 미리 로딩해서 처리하려해도 뭐가 없다.

반대로, DVD 플레이어는 저장된 비디오를 다 불러온 다음에 실행된다.

컬렉션과 스트림의 차이도 이런 것이다.

 

딱 한번만 탐색가능하다.

반복자와 마찬가지로 한 번만 탐색할 수 있다. → 즉, 탐색된 스트림의 요소는 소비된다!

• 또한 다시 탐색하려면 초기 데이터 소스에서 새로운 스트림을 만들어야 한다

List<String> title = Arrays.asList("Java8", "In", "Action");
Stream<String> s = title.stream();
s.forEach(System.out::println); //title의 각 단어를 출력
s.forEach(System.out::println); //IllegalStateException 발생

 

외부 반복과 내부 반복

1. 컬렉션 인터페이스를 사용하려면 사용자가 직접 요소를 반복해야 한다. → 외부반복

List<String> names = new ArrayList<>();
for(Dish dish: menu) { // 메뉴 리스트를 순차 반복한다.
		names.add(dish.getName()); // 이름을 추출해서 리스트에 추가한다.
}

Iterator 객체 이용

List<String> names = new ArrayList<>();
Iterator<String> iterator = menu.iterator();
while (iterator.hasNext()) { //명시적 반복
		Dish dish = iterator.next();
		names.add(dish.getName());
}

 

2. 반복을 알아서 처리하고 결과 스트림값을 어딘가에 저장한다. 어떤 작업 수행할 지만 지정 → 내부반복

List<String> names = menu.stream()
						  .map(Dish::getName) // map 메서드를 getName 메서드로 파라미터화 해서 요리명 추출
					 	  .collect(toList()); // 파이프라인을 실행, 반복자 필요 X

 

내부 반복이 더 좋은 이유

1. 작업을 투명하게 병렬로 처리하거나, 더 최적화된 다양한 순서로 처리할 수 있다.

2. 스트림의 내부 반복은 데이터 표현과 하드웨어를 활용한 병렬성 구현을 자동으로 선택한다.
   1. 반면, for-each와 같은 외부 반복에서는 병렬성을 스스로 관리해야 한다. (synchronized)

 

4. 스트림 연산

Stream 전반적인 그림

1. 중간 연산

• 중간 연산은 다른 스트림을 반환한다 ( 이제 좀 지겹..) → 그래서 이어질 수 있는 거

• 중간 연산은 게으르다.
  • 스트림 파이프라인을 구성할 뿐 스트림의 원소를 소비하지 않는다.
  • 반면에 최종 연산은 스트림의 원소를 소비하며 스트림 파이프라인을 최적화해서 최종 결과를 도출한다.

List<String> names = 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(toList());
System.out.println(names);

결과

filtering pork
mapping pork
filtering beef
mapping beef
filtering chicken
mapping chicken
[pork, beef, chicken]

 

보면 filter → map 으로 반복 처리 되고, 마지막에 합쳐진 형태를 알 수 있다.

스트림의 게으른 특성이 보인다.

filter 요청 들어오니까 그때서야 가져와서 필터링하고 끝. map도 마찬가지다.

여기서 알 수 있는 최적화 효과

1. 300 칼로리가 넘는 요리는 여러개였으나, 처음 세개만 선택된 점.
   1. 이건 limit과 쇼트 서킷이라는 기법 덕분이라는데 나도 지연 로딩이라 아직 모른다

2. filter와 map은 분명 서로 다른 중간 연산이지만 한 과정으로 병합되었다
   1. 하나의 (filter → map) 과정으로 묶임
   2. 이 기법을 루프 퓨전이라고 한다.

 

2. 최종 연산

이런식으로 최종 연산에 의해 void, List, Integer 등 스트림 이외의 값이 반환된다.

menu.stream().forEach(System.out::println);

 

3. 스트림 이용

스트림 이용 과정

1. 질의를 수행할 데이터 소스(like 컬렉션)

2. 스트림 파이프라인을 구성할 중간 연산 연결

3. 스트림 파이프라인을 실행하고 결과를 만들 최종 연산

 

• 스트림 파이프라인의 개념은 빌더 패턴과 비슷하다!
  • 빌더 패턴에서는 호출을 연결해서 설정을 만든다(= 중간 연산)
  • 그리고 준비된 설정에 build() 메서드를 호출한다. (= 최종 연산)

 

 

* 본 포스팅은 모던 자바 인 액션을 정리한 글입니다.