Chapter06 스트림으로 데이터 수집

6장에 들어가며..

이번 장의 초점은 최종 연산인 collect에 맞춰져 있다.

맛보기 - 통화별로 트랜잭션을 그룹화한 코드

<명령형 프로그래밍>
Map<Currency, List<Transaction>> transactionsByCurrencies = new HashMap<>();

for(Transaction transaction : transactions) {
    Currency currency = transaction.getCurrency();
    List<Transaction> transactionsForCurrency = transactionsByCurrencies.get(currency);
    if(transactionsForCurrency == null){
        transactionsForCurrency = new ArrayList<>();
        transactionsByCurrencies.put(currency, transactionsForCurrency);
    }
    transactionsForCurrency.add(transaction);
}

->

<함수형 프로그래밍>
Map<Currency, List<Transaction>> transactionsByCurrencies =
      transactions.stream().collect(Collectors.groupingBy(Transaction::getCurrency));

collect메서드를 통해 Collector 인터페이스를 사용하는데, groupingBy를 이용해서 각 키 버킷, 키 버킷에 대응하는 요소 리스트를 값으로 포함하는 맵이 만들어지게 된다.

Collect

• 스트림에서 지원하는 메서드
• collect(리듀싱)
• collect(Collector인터페이스 사용)

Collector

• 인터페이스
• 리듀싱 연산이 수행
• 스트림의 요소를 어떤 식으로 도출할지 지정

Collectors

• 유틸리티 클래스
• 정적 팩토리 메서드
• 기능
  • 스트림 요소를 하나의 값으로 리듀스하고 요약
  • 요소 그룹화
  • 요소 분할

리듀싱과 요약

스트림.collect를 통해 스트림의 모든 항목을 하나의 결과로 합칠 수 있다.

Collectors.maxBy, minBy - 스트림 값에서 최댓값과 최솟값 검색

Comparator<Dish> dishCaloriesComparator = Comparator.comparingInt(Dish::getCalories);

Optional<Dish> mostCalorieDish =
menu.stream()
    .collect(
        Collectors.maxBy(dishCaloriesComparator)
    );

• Optional반환
• 객체의 숫자 필드의 합계나 평균 연산 ⇒ 요약 연산

요약 연산

• Collectors.summingInt, double, long
• averagingInt, double, long
• summarizingInt
  • count, sum, min, average, max
  • getter

IntSummaryStatistics menuStatistics = menu.stream()
                      .collect(
                          Collectors.summarizingInt(Dish::getCalories)
                      );

Collectors.joining - 문자열 연결

• 각 객체에 toString메서드를 호출해서 모든 문자열을 하나의 문자열로 연결해서 반환
• StringBuilder가 활용됨

Collectors.reducing - 범용 리듀싱 요약 연산

• 모든 컬렉터는 reducing 팩토리 메서드로도 정의가 가능하다. 하지만, reducing이 아닌, 다른 팩토리 메서드를 사용하는 이유는 편의성 때문이다.

<인수가 3개인 reducing>
int totalCalories = menu.stream()
            .collect(Collectors.reducing(
                0, Dish::getCalories, (i, j) -> i + j)
            );

<인수가 1개인 reducing>
Optional<Dish> mostCalorieDish = menu.stream()
                     .collect(Collectors.reducing(
                         (d1, d2) ->
                             d1.getCalories() > d2.getCalories() ? d1 : d2)
                     );

• reducing에 들어가는 인수 3개
  • seed(identity)
  • mapper(Function)
  • BinaryOperator
• reducing에 들어가는 인수 1개
  • Optional반환 → 최소 2개 이상의 값이 필요하기 때문에
  • 첫번째 스트림 요소 = seed(identity)
  • 두번째 요소부터 BinaryOperator(seed, nextStream)

collect vs reduce

collect는 위에서 설명했던 것처럼 스트림의 요소를 어떤 식으로 도출할지 지정하는 특성을 갖고 있다. 즉 도출하려는 결과를 누적하는 컨테이너를 바꾸도록 설계되어 있는 가변형 메서드인 반면에 reduce는두 값을 하나로 도출하는 불변형 연산 이라는 점에서 의미론 적인 문제가 일어난다. 또 7장에서 다루는 병렬 처리 관련해서도 문제가 발생할 수 있다.

컬렉션 프레임워크 유연성 : 같은 연산도 다양한 방식으로 수행할 수 있다.

but 위에서 말했던 collect와 reduce처럼 용도에 맞는 형식으로 최대한 구현하는 것을 권장한다.

자신의 상황에 맞는 최적의 해법 선택

위에서 말했듯 컬렉션 프레임워크의 유연성 때문에 다양한 방식으로 동일한 결과를 낼 수 있지만, 방법에 따라 성능의 차이나 가독성의 문제가 생길 수 있다. 예를들면 reduce연산을 통해 누적 값을 검색하는 것이 아니라 mapToInt를 통해 IntStream으로 변환 후 .sum을 한다면 언박싱을 할 필요가 없어지므로 성능 향상을 볼 수 있을 것이다.

Collectors.groupingBy - 그룹화

<Type 기준으로 분류>
Map<Dish.Type, List<Dish>> dishesByType = menu.stream()
                          .collect(Collectors.groupingBy(Dish::getType));

<조건 기준 분류>
public enum CaloricLevel { DIET, NORMAL, FAT }

Map<CaloricLevel, List<Dish>> dishesByCaloricLevel =
menu.stream()
    .collect(
        groupingBy( dish -> {
                if (dish.getCalories() <= 400) return CaloricLevel.DIET;
                else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
                else return CaloricLevel.FAT;
            }));

• Dish.Type.values()을 통해 키값이 생성된다고 생각하면 되고, 이를 분류 함수(classification function)라고 부른다.
• 각 키를 기준으로 분류를 할 수 있다.
  • 위의 값들을 기준으로 좀 더 명확히 하기 위해 설명하자면
    List리스트에 있는 Dish::getType을 통해 Map<K, V>가 설정되며, K가 Dish::getType의 반환타입, V는 해당 객체 자체를 List에 담아 저장하는 것을 의미한다.

그룹화된 요소 조작

Collectors.filtering

Map<Dish.Type, List<Dish>> caloricDishesByType = 
menu.stream()
    .collect(groupingBy(Dish::getType,
        Collectors.filtering(dish -> dish.getCalories() > 500, toList())));

Collectors.mapping

Map<Dish.Type, List<Dish>> caloricDishesByType = 
menu.stream()
    .collect(groupingBy(Dish::getType, mapping(Dish:getName, toList())));

Collectors.flatMapping

Map<Dish.Type, List<Dish>> caloricDishesByType = 
menu.stream()
.collect(groupingBy(
        Dish::getType,
        flatMapping(dish -> dishTags.get(dish.getName()).stream,
        toSet())));

컬렉터 결과를 다른 형식에 적용하기

Optional같은 반환타입이 들어왔을 때 해당 값이 있다는 것을 보장한다면 고려할 수 있는 방법

.collect(groupingBy(Dish::getType, -> 분류함수
    collectingAndThen(maxBy(comparingInt(Dish::getCalories)), -> 컬렉터래핑
    Optional::Get))); -> 변환함수

컬렉션 형식을 바꾸는 방법

toCollection(HashSet::new); → TreeSet등 변환이 가능

partitioningBy - 분할

• 분할은 특수한 종류의 그룹화
• 분할은 분할 함수(partitioning function)라 불리는 프레디케이트
• 맵의 키 형식은 Boolean
• 한개의 인수를 받을 때
  • true false기준으로 구분
• 두개의 인수를 받을 때
  • 다중 맵으로 필터링할 수 있음
  • Map<Boolean, Map<Dish.Type, List<Dish>>> vegetarianDishesByType = menu.stream() .collect(partitioningBy( Dish::isVegetarian, ->true false groupingBy(Dish::getType)->Type별로 또 나눔 ));

분할의 장점

• 참, 거짓 두 가지 요소의 스트림 리스트를 모두 유지하는 것이 장점
• 때문에 분류 목록을 만들 때 활용하기 좋다

Collector 인터페이스

Collector 인터페이스는 리듀싱 연산을 어떻게 구현할지 제공하는 메서드 집합으로 구성된다.

Collector<T, A, R> 인터페이스의 시그니처

• T는 수집될 스트림 항목의 제네릭
• A는 누적자, 중간 결과를 누적하는 객체
• R은 수집 연산 결과 객체의 형식

Collector 인터페이스의 메서드

• Supplier<A> supplier()
  • 새로운 결과 컨테이너 만들기
  • 빈 누적자(seed) 인스턴스 만들기
  • ex) return () → new ArrayList();
• BiConsumer<A, T> accumulator()
  • 결과 컨테이너에 요소 추가하기
  • 리듀싱 연산을 수행하는 함수를 반환
  • n번째 요소를 탐색할 때 두 인수, 누적자와 n번째 요소를 함수에 적용한다.
  • A → 누적자 T를 A에 반영한 후 반환
  • ex) return List::add; or return (list, item) → list.add(item);
• Function<A, R> finisher()
  • 최종 변환값을 결과 컨테이너로 적용하기
  • 누적자 객체를 최종 결과로 변환
• BinaryOperator<A> combiner()
  • 두 결과 컨테이너 병합
  • 병렬 처리된 누적자를 결합하는 메서드
• SET<Characteristics> characteristics()
  • collect 메서드가 어떤 최적화(ex : 병렬화)를 이용해서 리듀싱 연산을 수행할 것인지 결정하도록 돕는 힌트
  • Characteristics은 각 특성을 담고있는 Enum 을 넣어서 힌트를 제공.
    • UNORDERED - 방문 순서나 누적 순서에 영향을 받지 않는다.
    • CONCURRENT - 다중 스레드에서 accumulator 함수를 동시에 호출할 수 있으며 병렬 리듀싱이 수행 가능하다.
    • IDENTITY_FINISH - 리듀싱 과정의 최종 결과에 누적자 객체를 바로 사용할 수 있는 것

응용하기

직접 List를 담는 ToListCollector를 구현해보자

//<version1 직접 interface 구현체 만들기>
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;

public class ToListCollectorTest<T> implements Collector<T, List<T>, List<T>> {

    @Override
    public Supplier<List<T>> supplier() {
        return ArrayList::new;
    }

    @Override
    public BiConsumer<List<T>, T> accumulator() {
        return List::add;
    }

    @Override
    public BinaryOperator<List<T>> combiner() {
        return (list1, list2) -> {
            list1.addAll(list2);
            return list1;
        };
    }

    @Override
    public Function<List<T>, List<T>> finisher() {
        return Function.identity();
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(Characteristics.IDENTITY_FINISH, Characteristics.CONCURRENT));
    }
}

-----------------------------------------

//<version2 간단한 리듀싱은 구현체 필요없음>
List<Dish> dishes = menuStream.collect(
        ArrayList::new,
        List::add,
        List::addAll
);

6장을 마치며

• collect는 스트림의 요소를 요약 결과로 누적하는 다양한 방법을 인수로 갖는 최종 연산이다.
• Collectors라는 Collector구현체를 통해 다양한 리듀싱 연산을 손쉽게 할 수 있다.
• groupingBy, partitioningBy로 스트림의 요소를 그룹화,분할할 수 있다.
• 다수준의 그룹화, 분할, 리듀싱 연산에 특화되어있다.
• Collector 인터페이스를 직접 구현해 커스텀 컬렉터를 개발, 기존의 컬렉터를 튜닝할 수 있다.

Chapter05 스트림 활용

필터링

스트림의 요소를 선택하는 방법 필터링

스트림 인터페이스가 지원하는 filter 메서드의 필터링 방법

• Predicate
  • 불린을 반환하는 함수를 인수로 받아서 필터링할 수 있다.
    • stream().filter(Dish::isVegetarian)
    • stream().filter(menu.price > 1000)
• 고유 요소 - distinct()
  • 고유 여부는 스트림에서 만든 객체의 hashCode, equals로 결정된다.

슬라이싱

스트림의 요소를 선택하거나 스킵하는 스트림

• Predicate - java9
  • takeWhile() - false가 등장하는 시점 직전까지의 데이터를 슬라이싱
  • dropWhile() - false 요소를 발견한 값 이후 슬라이싱
• 스트림 축소
  • .limit(n) - 발견하는 요소의 개수 발견 시 종료 → 정렬되지 않은 값에도 사용하기 용이함
• 요소 건너뛰기
  • .skip(n) - 발견하는 n개의 요소 스킵

매핑

특정 객체에서 특정 데이터를 선택하는 작업

• 스트림의 각 요소에 함수 적용

    List<Menu> menu ...
  
    List<String> dishNames = menu.stream()
                                                            .map(Dish::getName)
                                                            .collect(toList());
    => Stream<Menu> -> .map(Dish::getName) -> Stream<String>

• 평면화

  • flatMap() → Stream의 객체를 감싸는 것이 아니라 객체 자체를 반환하도록 한다.

    words.stream()
          .map(word -> word.split(""))//각 단어를 개별 문자를 포함하는 배열로 변환
                                                                  //Stream<String[]> or Stream<Stream<String>>
          .map(Arrays::stream) //String[]배열을 stream으로 감싸기
          .distinct()
          .collect(toList());
          //List<Stream<String>> 반환 -> 실패
    
    words.stream()
          .map(word -> word.split(""))
          .flatMap(Arrays::stream) // flatMap을 통해 만들어진 Stream<Stream<String>>을
                                                          //Stream<String>으로 평면화
          .distinct()
          .collect(toList());

flatMap은 각 배열을 스트림이 아니라 스트림의 콘텐츠로 매핑한다.(스트림의 언박싱 개념으로 이해)

검색

• 특정 속성이 데이터 집합에 있는지 여부를 검색하는 데이터 처리 기법 반환값은 Boolean

  • allMatch - 모두만족
  • anyMatch - 하나라도만족
  • noneMatch - 모두만족x
  • findFirst
  • findAny

• 쇼트서킷

  limit, allMatch, noneMatch, findFirst, findAny등의 Stream연산은 스트림의 모든 요소를 처리하지 않고도 결과 반환이 가능하다. 이러한 연산들을 쇼트서킷 연산이라고 부른다.

요소 검색

findAny 메서드는 현재 스트림에 있는 임의의 요소를 반환한다.

Dish dish = menu.stream()
        .filter(Dish::isVegetarian)
        .findAny();
 -> 컴파일 에러 (형태 불일치 findAny() -> Optional<Dish> 반환)

쇼트서킷을 통해 결과를 바로 받았지만, 이번에는 Optional이라는 개념이 나온다.

Optional이란?

만약 List

int sum = 0;
for(int x : numbers){
        sum += x;
}

->

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

List<Dish> menu = Dish.menu;
        //1, 2, 3, 4
    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();
            })
            .sorted()
            .limit(3)
            .collect(Collectors.toList());
    System.out.println(names);

Chapter04 스트림 소개

컬렉션의 역할

컬렉션은 자바에서 빠져서는 안되는 데이터를 그룹화하는 도구다.

모든 자바 애플리케이션에서 만들고 처리하고 있는 컬렉션이지만, 이 컬렉션에서 지원해주는 연산을 지원하지않는다.

때문에 우리가 해당 연산을 처리할 때 데이터를 처리하는 코드를 구현하는데, 해당 구현 방식이 다른 개발자가 봤을 때 명시적이지 않아 명확하지 않을 수 있다. 또 많은 요소를 포함하는 컬렉션은 처리 성능을 높이려면 병렬처리가 불가피한데, 병렬 처리 코드는 어렵다.

헛둘님

스트림이란 무엇인가

스트림은 자바 8 API에 추가된 기능이다.

스트림 API의 장점

• 컬렉션 데이터 반복을 편리하게 처리할 수 있다.
• 데이터를 멀티스레드를 활용하지 않아도 투명하게 병렬로 처리할 수 있다.
• 선언형으로 코드를 구현할 수 있다.
  • 루프와 if조건문 등의 블록 구현이 필요없음
• 여러 빌딩 블록 연산을 연결해서 복잡한 데이터 처리 파이프라인을 만들 수 있다.
• 선언형과, 블록연산을 파이프라인으로 연결하기 때문에 가독성과 명확성이 유지된다.

gpt답변

자바 8의 스트림API의 특징

• 선언형 : 더 간결하고 가독성이 좋아진다.
• 조립할 수 있음 : 유연성이 좋아진다.
• 병렬화 : 성능이 좋아진다.

스트림 시작하기

자바 8부터 Collections에서 스트림을 반환하는 stream() 메서드가 추가되었다.

스트림을 정의하자면 데이터 처리 연산을 지원하도록 소스에서 추출된 연속된 요소 이다.

• 연속된 요소 : 특정 요소 형식으로 이루어진 연속된 값 집합의 인터페이스를 제공한다.
  • 컬렉션의 주제는 데이터 스트림의 주제는 계산 이다.
• 소스 : 스트림은 컬렉션, 배열 등의 자원 데이터 제공 소스를 소비할 뿐이다. 소스를 그대로 사용하기 때문에 정렬된 컬렉션으로 스트림을 생성하면 정렬이 그대로 유지된다.
• 데이터 처리 연산 : 데이터베이스와 비슷한 연산을 지원한다. filter, map, reduce, find, match, sort… 등으로 데이터를 조작할 수 있는 연산을 지원한다.
• 파이프라이닝(Pipelining) : 스트림 연산 대부분은 파이프라인을 구성할 수 있도록 스트림 자신을 반환한다.
  • 게으름, 쇼트서킷 등과 같은 최적화도 얻을 수 있다.(5장 설명)
  • 연산 파이프라인은 데이터 소스에 적용하는 데이터베이스 질의와 비슷하다.
• 내부 반복 : 반복자를 이용해서 명시적으로 반복하는 컬렉션과 달리 스트림은 내부 반복을 지원한다.

스트림의 특징을 예제에 적용

import static java.util.stream.Collectors.toList;
public static List<String> getLowCaloricDishesNamesInJava8(List<Dish> dishes) {
    return dishes.stream() // 메뉴(요리 리스트)에서 스트림을 획득
                // 파이프라인 연산 시작
        .filter(d -> d.getCalories() < 400) // 1. 고칼로리 요리를 필터링으로 제외
        .sorted(comparing(Dish::getCalories)) // 2. 요리명 추출
        .map(Dish::getName) // 3. 선착순 세개만 선택
        .collect(toList()); // 4. 을 통해 나온 결과를 다른 리스트로 저장
  }

!!
.collect(toList()) -> add, remove 가능
.collect(Collectors.toUnmodfiableList()) -> 자바10
.toList() -> 자바16

불변 리스트, 변환가능한 리스트
List <- new ArrayList 변환가능
List.of() Arrays.asList() -> 불변리스트 set가능
toUnmodfiableList -> 불변리스트지만 List.of와 다름

• 데이터 소스 : 요리 리스트 → 연속된 요소를 스트림에 제공
• filter, sorted, map, collect : 데이터 처리 연산 - collect()를 제외한 연산은 파이프라인을 형성할 수 있도록 스트림을 반환
  • filter : 람다를 인수로 스트림에서 특정 요소를 제외시킨다.
  • map : 람다를 이용해서 한 요소를 다른 요소로 변환하거나 정보를 추출
  • limit : 정해진 개수 이상의 요소가 스트림에 저장되지 못하게 크기를 축소
  • collect : 스트림을 다른 형식으로 변환한다. toList()는 스트림을 리스트로 변환

스트림과 컬렉션

컬렉션과 스트림은 모두 연속된 요소 형식의 값을 저장하는 자료구조의 인터페이스를 제공한다.

여기서 연속된 이라는 표현은 순차적으로 값에 접근한다는 것을 의미한다.

이 둘은 연속된 값을 접근해서 처리하는 방식인데 무엇이 다른가? 했을 때

데이터를 언제 계산하느냐가 컬렉션과 스트림의 가장 큰 차이라고 꼽을 수 있다.

스트림 vs 컬렉션

• 스트림
  • 요청할 때만 요소를 계산하는 고정된 자료구조
  • 적극적 생성 : 모든 값을 계산할 때까지 기다림
  • 내부 반복(internal iteration)
• 컬렉션
  • 모든 요소는 컬렉션에 추가하기 전에 계산되어야 한다.
  • 게으른(Laziness) 생성 : 필요할 때만 값을 계산
  • 외부 반복(external iteration)

딱 한 번만 탐색할 수 있다.

Iterator와 동일하게 한번만 사용되고 버려진다. 재탐색을 위해서는 초기 데이터 소스에서 새로운 스트림을 만들어야 함

List<String> title = Arrays.asList("Java8", "In", "Action");
Stream<String> s = title.stream();
s.forEach(System.out::println);
s.forEach(System.out::println); -> IllegalStateException 발생!

외부 반복 보다 내부 반복이 좋다

명시적으로 처리 된 컬렉션 목록을 가져와서 처리하고, 처리한 컬렉션을 다시 다른 컬렉션에 담아서 처리하고… 방식이 상당히 번거롭다.

작업을 실행할 때 명시적으로 값 처리를 바로 바로 담아서 넣어줄 수 있고, 값을 처리할 때 명시적으로 어떤 일을 행하는지 볼 수 있다.

또 병렬처리를 관리하는 부분에서 좋다.

예시 ) 외부 반복 vs 내부 반복

<외부 반복>
List<String> highCaloricDishes = new ArrayList<>();
Iterator<String> iterator = menu.iterator();
while(iterator.hasNext()){
        Dish dish = iterator.next();
        if(dish.getCalories() > 300){
                highCaloricDishes.add(d.getName());
        }
}

->

<내부 반복>
List<String> highCaloricDish = menu.stream()
        .filter(dish -> dish.getCalories() > 300)
        .map(Dish::getName)
        .collect(toList());

스트림 연산

이제 스트림의 연산 방식을 예시와 함께 명칭으로 구분을 해보자.

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()); // 최종 연산
  }

• 중간 연산
  • 단말 연산을 스트림 파이프라인에 실행하기 전까지는 아무 연산도 수행하지 않는다는 것, 즉 게으르다 중간 연산을 합친 다음에 합쳐진 중간 연산 결과를 기반으로 최종 연산으로 한번에 처리하기 때문이다.
  • 쇼트서킷 기법을 통해 limit연산을 통해 갯수제한이 가능하다
  • 루프 퓨전 : 서로 다른 연산들을 한 과정으로 병합시키기도 한다.
• 최종 연산
  • 중간 연산을 다 마친 후에 나온 결과를 최종 처리하는 연산이다.

스트림 이용하기

스트림은 세 가지 방법으로 요약할 수 있다.

• 질의를 수행할 데이터 소스
• 스트림 파이프라인을 구성할 중간 연산 연결
• 스트림 파이프라인을 실행하고 결과를 만들 최종 연산

중간 연산 종류

• filter : Predicate
• map : Function
• limit : 개수제한
• sorted : 정렬
• distinct : 중복 제거

최종 연산 종류

• forEach : 각 요소를 소비하면서 람다 적용
• count : 스트림의 요소 개수 반환
• collect : 스트림을 리듀스해서 컬렉션을 만든다.

1.1 자바 8 버전 이후의 자바

자바8의 코드 간략화

<Java8 이전>
Collections.sort(inventory, new Comparator<Apple>(){
		public int compare(Apple a1, Apple a2) {
				return a1.getWeight().compareTo(a2.getWeight());	
		}
});

->

<Java8>
inventory.sort(comparing(Apple::getWeight));

위의 코드 예시와 같이 자바8에서는 비교 코드를 더욱 간략하게 표현이 가능해졌다.

자바언어의 가장 큰 변화를 가져왔던 자바 8이 들어오면서 바뀐 변화에 대해서 살펴볼 것이다.

• 멀티 코어를 활용한 연산 처리를 활용하기 쉬워졌다.
• 자바8 이전 버전에서는 싱글 코어가 아닌 방법을 활용하려면 스레드를 활용해서 병렬 실행 환경을 관리하는 형태였는데, 이는 구현부터 관리까지 비용이 많이 들었다. 이를 쉽게 해결하기 위한 방식을 소개해준다.
• 우리가 배울 자바8은 큰 틀로 보았을 때 세가지 기능이 추가되었다.
  • 스트림 API(Stream API)
  • 메서드에 코드를 전달하는 기법
  • 인터페이스의 디폴트 메서드

또 기존 버전과의 큰 변화점을 설명하자면

첫째, 병렬 연산이 쉬워졌다.

병렬연산을 지원하는 Stream API가 있는데 이를 활용하면 기존의 멀티코어 환경에서 사용하는 synchronized 키워드를 사용하지 않아도 된다.

또 Stream API에서 메서드에 코드를 전달하는 기법과 인터페이스의 디폴트 메서드를 전달해 줄 수 있을 것이다.

둘째, 코드가 간결해졌다.

메서드에 코드를 전달하는 기법이 생기면서(메서드 참조, 람다)

앞의 예시에서 보았던 짧은 코드가 된 것이다.

1.2 왜 아직도 자바는 변화하는가

많은 언어들이 등장하고 사라지는 와중에 자바 언어는 처음부터 객체지향의 특성을 살리고, 스레드와 락을 이용한 동시성도 지원을 했었다. 이로 인해 자바는

대중적인 언어로 발전했고, 빅데이터 트랜드가 생긴 이후로는

빅 데이터 처리를 할 때 효율적인 방법인 병렬프로세싱이 필요한데, 자바는 병렬에는 약했었다. 이와 같이 변화하는 트랜드에 맞춰서 개발 언어도 발전한 것이다.

자바 8버전의 프로그래밍 개념

첫번째 개념 - 스트림 처리

이는 한번에 하나의 항목을 처리하던 기존 방식이 아닌, 스트림 파이프라인을 통해 값을 처리할 때 여러 cpu에 할당하여 병렬 처리를 돕기도 하고, 스트림을 통해 한 데이터객체에 대한 동작처리를 다양하게 처리할 수 있다.

두번째 개념 - 동작 파라미터화

객체의 동작을 행할 때 동작 안에 다른 동작을 넣는 방법이라고 생각하면 된다. 객체 안의 메서드에서 다른 메서드를 같이 실행하는 것이다.

8버전 전에는 이러한 방식을 구현하려면 동작을 구현한 객체를 생성해서 해당 객체를 파라미터로 넣었어야 했다.

세번째 개념 - 병렬성

성능에 악영향을 끼치는 synchronized 키워드를 사용하지 않고도 병렬처리가 가능한데, 이 이유는 stream은 공유되지 않는 가변 데이터를 통해 처리가 이루어지기 때문에 해당 스트림이 진행되는 동안은 값이 변하지 않고 처리 마지막에 값이 변한다.

1.3 자바 함수

프로그래밍 언어에서는 값을 바꾸며, 전달하는 것이 핵심 가치인데, 이 핵심 가치를 이룰 수 있는 것에 일급 이라는 말이 붙는다.

이전의 버전에서는 메서드나 클래스 등이 일급 객체가 될 수 없었는데, 클래스나 메서드 등 자체의 값을 전달할 수 있는 값이 되도록 일급화 시키는게 가능해졌다.

메서드와 람다를 일급으로

<Java8 이전>
File[] hiddenFiles = new File(".").listFiles(new FileFilter(){
		public boolean accept(File file){
				return file.isHidden();
		}

}

->

<Java8>
File[] hiddenFiles = new File(".").listFiles(File::isHidden);

이러한 변경에서 사용한 기법을 메서드참조라고 하는데 File객체에 있는 isHidden()메서드가 구현되어있다면 위와 같이 불러올 수 있는 것이다.

이전의 자바 버전에서는 ::형태를 사용하지 못했기 때문에 이급 메서드였다.

하지만 버전이 바뀌고 8버전부터는 메서드참조가 가능하기 때문에 일급 메서드로 바뀌었다.

장점

• 코드의 간결성
• 직관적

람다(익명 함수)

람다도 값으로 취급할 수 있는데

(int x) -> x + 1

의 값이 있다면 ‘x라는 인수로 호출하면 x+1를 반환하라’라는 명령을 가진 함수를 만들 수 있는 것이다.

이런 람다 문법으로 구현된 프로그램을 함수형 프로그래밍, 즉 ‘함수를 일급값으로 넘겨주는 프로그램을 구현한다.’라고 한다.

코드 넘겨주기

전체 범위에서 특정 항목을 선택해서 반환하는 동작을 필터라고 하는데 이런 필터를 자바 8 이전에는 상당히 긴 코드로 구현되었을 것이다.

필터를 새로 생성하면 또 새로 메서드를 구현해야할 것이다. 비슷한 코드니 Copy&Paste를 할텐데 이렇게 구현을 지속하게되면 코드를 수정해야할 때 구현한 모든 메서드 내부를 수정하거나 할텐데 이는 상당히 비효율적이다.

자바 8버전 에서는 반복을 제거하면서 가독성까지 챙길 수 있는데 예시를 보면서 이해해보자

<Java8 이전>
public static List<Apple> filterGreenApples(List<Apple> inventory) {
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory) {
      if ("green".equals(apple.getColor())) {
        result.add(apple);
      }
    }
    return result;
  }

  public static List<Apple> filterHeavyApples(List<Apple> inventory) {
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory) {
      if (apple.getWeight() > 150) {
        result.add(apple);
      }
    }
    return result;
  }

->

<Java8 이후>
public static boolean isGreenApple(Apple apple) {
    return "green".equals(apple.getColor());
  }

  public static boolean isHeavyApple(Apple apple) {
    return apple.getWeight() > 150;
  }

  public static List<Apple> filterApples(List<Apple> inventory, Predicate<Apple> p) {
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory) {
      if (p.test(apple)) {
        result.add(apple);
      }
    }
    return result;
  }

이 코드에서 다른 점은

if ("green".equals(apple.getColor())) {
        result.add(apple);
      }

if (apple.getWeight() > 150) {
        result.add(apple);
      }
->

if (p.test(apple)) {
        result.add(apple);
      }

이 두곳이 주요한데, Predicate(함수형 인터페이스) p를 상속받은 filterApple이 되었고 해당 p에 있는 test를 실행할 뿐이다.

이를 호출할 때는 filterApples(inventory, Apple::isGreenApple);

형식으로 호출하는데, 여기서 알게 된 사실은 자바8에서는 이와 같이 메서드동작 자체를 전달할 수 있다는 것을 알 수 있게 되었다.

가장 대표적인 함수형 인터페이스 4가지

<aside> 💡 자바에서 지원하는 함수형 인터페이스로는 대표적으로 크게 네가지가 있다.

• Supplier<T> - 공급자 : 매개변수는 없고 반환값만 있다
  • get()
• Consumer<T> - 사용자 : 매개변수는 있고, 반환값이 없다
  • accept()
• Function<T, R> - 함수 : 일반적인 함수형태, 하나의 매개변수를 받아 결과를 반환
  • apply()
• Predicate<T> - 매개변수 하나를 받아서 boolean타입으로 반환한다
  • test()

T는 제네릭타입을 뜻하고, R은 리턴타입을 뜻한다.

추가로 Bi가 붙은 형태가 있는데 다른 방법은 똑같고 매개변수가 두개 들어간다는 의미이다.

</aside>

메서드 전달에서 람다로

아까 위에서 구현했던 함수형 인터페이스의 자리에 메서드가 아니라 람다로 익명 메서드를 사용해도 동일하게 동작할 수 있다.

public static List<Apple> filterApples(List<Apple> inventory, Predicate<Apple> p) {
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory) {
      if (p.test(apple)) {
        result.add(apple);
      }
    }
    return result;
  }

<aside> 💡 filterApples(inventory, (Apple a) → GREEN.equals(a.getColor()));

filterApples(inventory, () → GREEN.equals(Apple::getColor));

filterApples(inventory, () → Apple::Weight() < 80);

…

</aside>

람다의 코드가 너무 길다면 메서드참조를 하는 것이 코드의 명확성을 위해 더 좋을 것이다.

1.4 스트림

거의 모든 자바 애플리케이션을 컬렉션을 만들고 활용한다. 이 컬렉션을 통해서 값을 추출하고 필터하고, 등등 여러 작업을 시행하는데 이 동작을 코드로 작성하려면 자바8 이전에는 많은 코드 구현이 필요했다.

자바8부터는 스트림API가 도입되면서 해당 코드들을 전부 돌면서 데이터를 확인해야하는 for문 제거가 가능하고, 또 라이브러리 내부에서 모든 데이터가 처리되기 때문에 기존의 방식보다 더욱 간편하고 흐름을 읽기가 쉬운 코드로 변경될 것이다.

또 api자체에서 지원하는 병렬처리도 손쉽게 가져올 수 있을 것이다.

멀티스레딩은 어렵다

자바8이전의 멀티스레딩 환경은 구현부터 어려움이 있었는데, 스트림API에서 지원하는 병렬처리로 손쉽게 멀티스레딩 환경을 구축할 수 있게 되었다.

1.5 디폴트 메서드와 자바 모듈

자바8 이전의 List 인터페이스는 List의 스트림을 처음에는 지원하지 않았기 때문에 .sort라는 코드가 없었는데, 이를 자바8에서는 어떻게 구현을 했을까 한다면

default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

인터페이스에 sort메서드를 추가하는 방법도 있겠지만, 이를 넣는다면 List인터페이스를 상속하는 모든 코드에 sort의 세부 구현을 우리가 해야한다.

이를 방지하기 위해서 자바8 개발자는 default메서드를 인터페이스에도 넣을 수 있게 변경이 되었고, 이 인터페이스 변경과 함께 a.sort()같은 형태로도 구현이 가능하게 되었다.

코드를 보면 받은 객체를 Arrays.sort()로 보내주는 형식이다.