📌모던 자바 인 액션 Chapter 5. 스트림 활용

📖 5.1 필터링

프레디케이트 필터링 방법과고유 요소만 필터링하는 방법을 배운다.

5.1.1 프리디케이트로 필터링

filter 메서드는 프레디케이트(불리언을 반환하는 함수)를 인수로 받아서 프레디케이트와 일치하는 모든 요소를 포함하는 스트림을 반환한다.

// 채식요리를 필터링해서 메뉴 만들기
List<Dish> vegetarianMenu = menu.stream()
								.filter(Dish::lsVegetarian)
								.collect(toList())；

5.1.2 고유 요소 필터링

// 리스트의 모든 짝수를 선택하고 중복을 필터링
List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4); 
numbers.stream()
	   .filter(i -> i % 2 == 0)
	   .distinct()
	   .forEach(System.out::println);

📖 5.2 스트림 슬라이싱

스트림의 요소를 선택하거나 스킵하는 다양한 방법을 설명한다.

5.2.1 프레디케이트를 이용한 슬라이싱

TAKEWHILE 활용

다음과 같은 특별한 요리 목록을 갖고 있다고 가정하자.

List<Dish> specialMenu = A rrays.asList(
	new Dish("seasonal fruit", true, 120, Dish.Type.OTHER), 
	new Dish("prawns", false, 300, Dish.Type.FISH), 
	new Dish("rice", true, 350, Dish.Type.OTHER), 
	new Dish("chicken", false, 400, Dish.Type.MEAT), 
	new Dish("french fries", true, 530, Dish.Type.OTHER));

어떻게 320칼로리 이하의 요리를 선택할 수 있을까?
본능적으로 앞에서 배운 filter를 다음처럼 이용할수 있다는 생각이 들 것이다.

List<Dish> filteredMenu 
	= specialMenu.stream()
			 	 .filter(dish -> dish.getCalories() < 320)
			 	 .collect(toList()); 

리스트가 이미 칼로리 순으로 정렬되엉 있다는 사실에 주목하자.
filter를 사용하면 모든 요소에 적용할 것이다.
정렬되어 있다면 320칼로리 보다 크거나 같은 요리가 나왔을 때 반복을 멈추는 것이 효율적이다.
takeWhile을 사용하면 이를 간단히 처리할 수 있다.

List<Dish> slicedMenul 
	= specialMenu.stream()
				 .takeWhile(dish -> dish.getCalories() < 320)
				 .collect(toList()); 

DROPWHILE 활용

320칼로리보다 큰 요소는 어떻게 탐색할까?
dropWhile을 이용해 이작업을 완료할 수 있다.

List<Dish> slicedMenu2 
	= specialMenu.stream()
				 .dropWhile(dish -> dish.getCalories() < 320)
				 .collect(toList())

프레디케이트가 거짓이 되면 그 지점에서 작업을 중단하고 남은 모든 요소를 반환한다. dropWhile은 무한한 남은 요소를 가진 무한 스트림에서도 동작한다.

5.2.2 스트림 축소

스트림은 주어진 값 이하의 크기를 갖는 새로운 스트림을 반환하는 limit(n) 메서드를 지원한다. 스트림이 정렬되어 있으면 최대 요소 n개를 반환할 수 있다.

List<Dish> dishes = specialMenu.stream()
							   .filter(dish -> dish.getCalories() > 300)
							   .limit(3)
							   .collect(toList()); 

정렬되지 않은 스트림(예를 들면 소스가 Set)에도 limit를 사용할 수 있다. 소스가 정렬되어있지 않았다면 limit의 결과도 정렬되지 않은상태로 반환된다.

5.2.3 요소 건너뛰기

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

List<Dish> dishes = menu.stream()
						.filter(d -> d.getCalories() > 300)
						.skip(2)
						.collect(toList());

퀴즈 5-1. 필터링

// 스트림을 이용해서 처음 등장하는 두 고기 요리를 필터링하시오.
List<Dish> dishes =
	menu.stream()
		.filter(d -> d.getType() == Dish.Type.MEAT)
		.limit(2)
		.collect(toList());

📖 5.3 매핑

5.3.1 스트림의 각 요소에 함수 적용하기

스트림은 함수를 인수로 받는 map 메서드를 지원한다. 인수로 제공된 함수는 각 요소에 적용되며 함수를 적용한 결과가 새로운 요소로 매핑된다.

// 요리명을 추출하는 코드
List<String> dishNames = menu.stream()
					 		  .map(Dish::getName)
					 		  .collect(toList());

getName은 문자열을반환하므로 map 메서드의 출력 스트림은 Stream<String> 형식을 갖는다.

// 각 요리명의 길이를 알고 싶다면 어떻게 해야 할까?
List<Integer> dishNameLengths = menu.stream()
									.map(Dish::getName)
									.map(String::length)
									.collect(toList());

5.3.2 스트림 평면화

["Hello", "World"] 리스트가 있다면 결과로 ["H", "e", "ㅣ", V , "W", "r", d']를포함하는 리스트가 반환되어야 한다고 가정하자.

words.stream()
	 .map(word -> word.split(""))
	 .distinct()
	 .collect(toList());

다음과 같이 생각했을 수 있지만 map으로 전달한 람다는 각 단어의 String[](문자열 배열)을 반환한다는 점이 문제다. 따라서 map 메소드가 반환한 스트림의 형식은 Stream<String[]>이다. 우리가 원하는 것은 문자열의 스트림을 표현할 Stream<String>이다.

flatMap이라는 메서드를 이용해서 이문제를 해결할 수 있다.

map과 Arrays.stream 활용

문자열 배열을 받아 문자열 스트림으로 변환하는 방법을 알아야 한다.
그 역할을 Arrays.stream가 해준다.

String[] arrayOfWords = {"Goodbye", "World"};
Stream<String> streamOfwords = Arrays.stream(arrayOfWords);

위 예제의 파이프라인에 Arrays.stream() 메서드를 적용해보자.

words.stream()
	 .map(word -> word.split("")) // 각 단어를 개별 문자열 배열로 변환 
	 .map(Arrays::stream) // 각 배열을 별도의 스트림으로 생성 
	 .distinct()
	 .collect(toList());

List<Stream<String>>가 만들어지면서 문제가 해결되지 않는다.
문제를 해결하려면 먼저 각 단어를 개별 문자열로 이루어진 배열로 만든 다음에 각 배
열을 별도의 스트림으로 만들어야 한다.

flatMap 사용

List<String> uniqueCharacters = 
	words.stream()
		 .map(word -> word.split("")) // 각 단어를 개별 문자를 포함히는 배열로 변환 
		 .flatMap(Arrays::rstream) // 생성된 스트림을 하나의 스트림으로 평면화 
		 .distinct()
		 .collect(toList());

map(Arrays::stream)과 달리 flatMap은 하나의 평면화된 스트림을 반환한다.

퀴즈 5-2 매핑

1. 숫자 리스트가 주어졌을 때 각 숫자의 제곱근으로 이루어진 리스트를 반환하시오. 예를들어 [1, 2, 3, 4, 5]가주어지면 [1. 4, 9, 16, 25]를 반환해야 한다.

정답

List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> collect = nums.stream()
                			.map(num -> num * num)
                			.collect(Collectors.toList());

2. 두 개의숫자 리스트가 있을 때 모든 숫자쌍의 리스트를 반환하시오. 예를 들어 두 개의 리스트 [1, 2, 3]과 [3, 4]가 주어지면 [(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]를 반환해야 한다.

정답

List<Integer> numbers1 = Arrays.asList(1, 2, 3);
List<Integer> numbers2 = Arrays.asList(3, 4);
List<int[]> pairs = 
			numbers1.stream()
            		.flatMap(i -> numbers2.stream().map(j -> new int[]{i, j}))
                    .collect(Collectors.toList());

3. 이전 예제에서 합이 3으로 나누어떨어지는 쌍만 반환하려면 어떻게 해야할까? 예를들어 (2,4), (3,3)을반환해야한다.

1) 책 방법
List<Integer> numbers1 = Arrays.asList(1, 2, 3);
        List<Integer> numbers2 = Arrays.asList(3, 4);
        List<int[]> pairs = numbers1.stream()
                .flatMap(i -> numbers2.stream()
                        .filter(j -> (i+j) % 3 == 0)
                        .map(j -> new int[]{i, j}))
                .collect(Collectors.toList());

2) 내 방법
List<Integer> numbers1 = Arrays.asList(1, 2, 3);
        List<Integer> numbers2 = Arrays.asList(3, 4);
        List<int[]> pairs = numbers1.stream()
                .flatMap(i -> numbers2.stream().map(j -> new int[]{i, j}))
                .filter(i -> Arrays.stream(i).sum() % 3 == 0)
                .collect(Collectors.toList());

📖 5.4 검색과 매칭

5.4.1 프레디케이트가 적어도 한 요소와 일치하는지 확인

프레디케이트가 주어진 스트림에서 적어도 한 요소와 일치하는지 확인할 때 anyMatch 메서드를 이용한다. 예를 들어 다음 코드는 menu에 채식요리가 있는지 확인하는 예제다.

if(menu.stream().anyMatch(Dish::isVegetarian)) {
	System.out.println("The menu is (somewhat) vegetarian friendly!!");
}

5.4.2 프레디케이트가 모든 요소와 일치하는지 검사

스트림의 모든 요소가 주어진 프레디케이트와 일치하는지 검사한다. 예를 들어 메뉴가 건강식(모든 요리가 1000칼로리 이하면 건강식으로 간주) 인지 확인할 수 있다.

boolean isHealthy = menu.stream()
						.allMatch(dish -> dish.getCalories() < 1000);

NONEMATCH

noneMatch는 allMatch와 반대 연산을 수행한다. 즉, noneMatch는 주어진 프레디케이트와 일치하는요소가 없는지 확인한다.

boolean isHealthy = menu.stream()
						.noneMatch(d -> d.getCalories() >= 1000);

anyMatch, allMatch, noneMatch 세 메서드는 스트림 쇼트서킷 기법，즉 자바의 &&，||와 같은 연산을 활용한다.
예를 들어 if(false && true && true) 라면 첫번째 false가 나오면 바로 if문 검사를 끝낸다.(뒤에 true는 보지도 않음)

5.4.3 요소 검색

findAny 메서드는 현재 스트림에서 임의의 요소를 반환한다. 예를 들어 다음 코드처럼 filter와 findAny를 이용해서 채식요리를 선택할수 있다.

Optional<Dish> dish = 
	menu.stream()
		.filter(Dish::isVegetarian)
		.findAny();

스트림 파이프라인은 내부적으로 단일 과정으로 실행할 수 있도록 최적화된다. 즉, 쇼트서킷을 이용해서 결과를 찾는 즉시 실행을 종료한다.

Optional 이란?

Optional<T> 클래스(java.util.Optional)는 값의 존재나 부재 여부를 표현하는 컨테이너 클래스다. 이전 예제에서 findAny는 아무 요소도 반환하지 않을 수 있다. null은 쉽게 에러를 일으킬 수 있으므로 자바 8 라이브러리 설계자는Optional<T>를 만들었다. 자세한건 10장에서 알아보자.

다음 사실만 알아두자!

• isPresent()는 Optional이 값을 포함하면 참(true)을 반환하고, 값을 포함하지 않으면 거짓(false)을 반환한다.
• ifPresent (Consumer<T>) block)은 값이 있으면 주어진 블록을 실행한다.
• T get ()은 값이 존재하면 값을 반환하고, 값이 없으면 NoSuchElementException을 일으킨다.
• T orElse(T other)는 값이 있으면 값을 반환하고，값이 없으면 기본값을 반환한다.

menu.stream()
	.filter(Dish::isVegetarian)
	.findAny() // Optional<Dish> 반환
	.ifPresent(dish -> System.out.println(dish.getName()); 
    // 값이 있으면 출력되고 없으면 아무 일도 일어나지 않는다.

5.4.4 첫 번째 요소 찾기

스트림에서 첫 번째 요소를 찾으려면 어떻게 해야 할까?

List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> firstSquareDivisibleByThree = 
		someNumbers.stream()
				   .map(n -> n * n)
				   .filter(n -> n % 3 == 0)
				   .findFirst(); // 9

findFirst VS findAny
병렬 실행에서는 첫 번째 요소를 찾기 어렵다. 따라서 요소의 반환 순서가 상관없다면 병렬 스트림에서는 제약이 적은 findAny를 사용한다.

📖 5.5 리듀싱

리듀싱 연산 : 모든 스트림 요소를 처리해서 값으로 도출
함수형 프로그래밍 언어 용어로는 이 과정이 마치 종이(우리의 스트림)를 작은 조각이 될 때까지 반복해서 접는 것과 비슷하다는 의미로 폴드(fold)라고 부른다.

5.5.1 요소의 합

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

// 스트림에서 다음과 같이 사용할 수 있다.
int sum = numbers.stream().reduce(0, (a, b) -> a + b); 

첫번째 요소 : 초깃값 0
두번째 요소 : BinaryOperator<T>

초깃값 없음

Optional<Integer> sum = numbers.stream().reduce((a, b) -> (a + b));

초깃값이 없으면 왜 Optional을 반환할까?
초깃값도 없고 스트림에 아무 요소도 없다면 합계가 없음을 가리킬 수 있도록 Optional 객체로 감싼 결과를 반환해야 한다.

5.5.2 최댓값과 최솟값

// 최대값
Optional<Integer> max = numbers.stream().reduce(Integer::max);
// 최솟값
Optional<Integer> min = numbers.stream().reduce(Integer::min);

퀴즈 5-3 리듀스

map과 reduce 메서드를 이용해서 스트림의 요리 개수를 계산하시오.

int count = menu.stream()
				.map(d -> 1)
                .reduce(0, (a, b) -> a + b);

reduce 메서드의 장점과 병렬화

반복적인 합계에서는 sum 변수를 공유해야 하므로 쉽게 병렬화하기 어렵다. 강제적으로 동기화시키더라도 결국 병렬화로 얻어야 할 이득이 스레드 간의 소모적인 경쟁 때문에 상쇄되어 버린다. 즉 이 작업을 병렬화하려면 입력을 분할하고, 분할된 입력을 더한 다음에, 더한 값을 고쳐야 한다.
하지만 스트림을 이용하면 쉽게 병렬화 할 수 있다.

int sum = numbers.parallelStream(),reduce(0, Integer::sum);

위 코드를 병렬로 실행하려면 대가를 지불해야 한다. 즉, reduce에 넘겨준 람다의 상태(인스턴스 변수같은)가 바뀌지 말아야 하며, 연산이 어떤순서로 실행되더라도 결과가 바뀌지 않는 구조여야 한다.

스트림 연산 : 상태 없음과 상태 있음

map, filter 등은 입력 스트림에서 각 요소를 받아 0 또는 결과를 출력 스트림으로보낸다. 따라서 (사용자가 제공한 람다나 메서드 참조가 내부적인 가변 상태를 갖지 않는다는 가정하에) 이들은 보통 상태가 없는, 즉 내부 상태를 갖지 않는 연산(stateless operation)이다.

하지만 reduce, sum, max 같은 연산은 결과를 누적할 내부 상태가 필요하다. 예제의 내부 상태는 작은값이다. 우리 예제에서는 int 또는 double을 내부 상태로 사용했다. 스트림에서 처리하는 요소수와 관계없이 내부 상태의 크기는 한정되어 있다.

반면 sorted나 distinct 같은 연산은 filter나 map처럼 스트림을 입력으로 받아 다른 스트림을 출력하는 것처럼 보일수 있다. 하지만 sorted나 distinct는 filter나map과는 다르다. 스트림의 요소를 정렬하거나 중복을 제거하려면 과거의 이력을 알고 있어야 한다. 예를 들어 어떤요소를 출력 스트림으로 추가하려면 모든 요소가 버퍼에 추가되어 있어야 한다. 연산을 수행하는 데 필요한 저장소 크기는 정해져있지 않다. 따라서 데이터 스트림의 크기가 크거나 무한이라면 문제가 생길수 있다. 이러한 연산을 내부상태를 갖는 연산이라 한다.

정리하자면 map, filter처럼 내부 상태를 갖지 않는 메서드와 reduce, sum, max, sorted, distinct처럼 내부 상태를 가지고 있어야 하는 메서드가 존재한다.

📖 5.7 숫자형 스트림

다음과 같이 메뉴의 칼리로 합계를 계산할 수 있다.

int calories = menu.stream()
					.map(Dish::getCalories)
  					.reduce(0, Integer::sum);

사실 위 코드에는 박싱 비용이 숨어있다. 내부적으로 합계를 계산하기 전에 Integer를 기본형으로 언박싱 해야한다.
다음 코드처럼 직접 sum메서드를 호출할 수 있다면 좋지 않을까?

int calories = menu.stream()
					.map(Dish::getCalories)
  					.sum();

하지만 이 코드도 sum()메서드를 직접 호출할 수 없다. map이 Stream<T>를 생성하기 때문이다. 스트림의 요소 형식은 Integer지만 인터페이스에는 sum 메서드가 없다.
왜 sum 메서드가 없을까? 예를들어 menu처럼 Stream<Dish> 형식의 요소만 있다면 sum이라는 연산을 수행할 수 없기 때문이다.

그럼 계속 박싱 비용을 감수하고 reduce를 사용해야 할까?
다행히 스프림 API에서는 기본형 특화 스트림을 제공한다.

5.7.1 기본형 특화 스트림

IntStream, DoubleStream, LongStream이 존재한다.

숫자 스트림으로 매핑

mapToInt, mapToDouble, mapToLong 세 가지 메서드를 가장 많이 사용한다.
map과 정확히 같은 기능을 수행하지만，Stream<T> 대신 특화된 스트림을 반환한다.(IntStream)

int calories = menu.stream() // Stream<Dish> 반환
				   .mapToInt(Dish::getCalories) // IntStram반환
				   .sum();

객체 스트림으로 복원하기

숫자 스트림을 원상태인 특화되지 않은 스트림으로 복원할 수 있을까? boxed

IntStrea mintStream = menu.stream().mapToInt(Dish::getCalories);
Stream<Integer> stream = intStream.boxed(); // 숫자 스트림을 스트림으로 변환

기본값: Optionallnt

스트림의 요소가 없을 경우 최대, 최소는 없을 것이다. 어떻게 해야할까?

Optionallnt maxCalories = menu.stream()
							  .mapToInt(Dish::getCalories)
							  .max();

Optionallnt로 반환하면 된다. 최대값이 없는 경우 기본값을 명시적으로 정의할 수 있다.

int max = maxCalories.orElse(1);

5.7.2 숫자 범위

IntStream evenNumbers = IntStream.rangeClosed(1, 100) // [1,100] 포함
								.filter(n -> n % 2 == 0);
System.out.println(evenNumbers.count()); // 50개

range(1,100) // 49개, (1,100) 미포함

5.7.3 숫자 스트림 활용 : 피타고라스 수

생략하겠뜸.. 배보다 배꼽이 더 커지는거 같아서 개인적으로 공부!

📖 5.8 스트림 만들기

이 절에서는 일련의 값, 배열, 파일, 심지어 함수를 이용한 무한 스트림 만들기 등 다양한 방식으로 스트림을 만드는 방법을 설명한다.

5.8.1 값으로 스트림 만들기

임의의 수를 인수로 받는 정적 메서드 Stream.of를 이용해서 스트림을 만들 수 있다.

Stream<String> stream = Stream.of("Modern", "Java", "In", "Action");
stream.map(String::toUpperCase).forEach(System.out::println);

// empty 메서드를 이용해서 스트림을 비울수 있다.
Stream<String> emptyStream = Stream.empty();

5.8.2 null이 될 수 있는 객체로 스트림 만들기

자바 9 이전에는 다음과 같이 null을 확인해줘야 했다.

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

getProperty : 자바를 실행할 때, 실행되는 곳의 정보를 얻어오거나 운영체제의 정보가 필요할 때가 있다. 실행 위치에 있는 파일을 읽어드려야 하는데, 현재 위치를 알 수 있는 방법 등 시스템의 정보를 가져올 때 System.getProperty(key) 를 사용한다.
key는 java 시스템 속성목록 검색하면 나온다.

하지만 자바 9이후에는 다음과 같이 코드를 구현할 수 있다.

Stream<String> homeValueStream
	= Stream.ofNullable(System.getProperty("home"));

null이 될 수 있는 객체를 포함하는 스트림값을 flatMap과 함께 사용하는 상황에서는 이 패턴을 더 유용하게 사용할 수 있다.

Stream<String> values =
			Stream.of("config", "home", "user")
				  .flatMap(key -> Stream.ofNullable(System.getProperty(key)));

5.8.3 배열로 스트림 만들기

Arrays.stream을 이용하기

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

5.8.4. 파일로 스트림 만들기

long uniqueWords = 0;
// AutoCloseable이므로 try—finally가 필요없다.
try(Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) { 
	uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" "))) 
					   .distinct()
					   .count();
} catch (IOException e) {
	// 예외처리
}

Paths.get("data.txt") : "data.txt"에 해당하는 Path 객체 반환
Files.lines : 해당 경로에 있는 파일 읽어서 스트림으로 반환

5.8.5 함수로 무한 스트림 만들기

정적 메서드 Stream.iterate와 Stream, generate를 제공한다. 두 연산을 이용해서 무한 스트림, 즉 고정된 컬렉션에서 고정된 크기로 스트림을 만들었던 것과는 달리 크기가 고정되지 않은 스트림을 만들 수 있다.
iterate와 generate에서 만든 스트림은 요청할 때마다 주어진 함수를 이용해서 값을 만든다. 따라서 무제한으로 값을 계산할수 있다. 하지만 보통 무한한 값을 출력하지 않도록 limit(n) 함수를 함께 연결해서 사용한다.

iterate 메서드

Stream.iterate(0, n -> n + 2)
	  .limit(10)
	  .forEach(System.out::println);

초기값 0, 람다를 이용해서 무한한 짝수 스트림을 만들 수 있다.
이러한 무한 스트림을 언바운드 스트림이라고 부른다.

퀴즈 5-4 피보나치열 집합

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55... 같은 식으로 구성된다. 무한 스트림으로 어떻게 구현해야 할까?

Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0] + t[1]})
	.limit(10)
	.map(t -> t[0])
	.forEach(System.out::println);

자바 9의 iterate 메소드는 프레디케이트를 지원한다. 예를 들어 0에서 시작해서 100보다 크면숫자 생성을 중단하는 코드를 다음처럼 구현할수 있다.

IntStream.iterate(0, n -> n < 100, n -> n + 4)
		 .forEach(System.out::println);

다음과 같이 filter을 이용해도 되지 않을까?

IntStream.iterate(0, n -> n + 4)
		 .filter(n -> n < 100)
		 .forEach(System.out::println);

아쉽게도 이 코드는 무한스트림을 만든다. filter 입장에서는 언제 이 작업을 중단해야 하는지 알 수 없기 때문이다.

스트림 쇼트서킷을 지원하는 takeWhile을 이용하는 것이 해법이다.

IntStream.iterate(0 , n - > n + 4)
		 .takeWhile(n -> n < 100)
		 .forEach(System.out::println);

generate 메서드

iterate와 달리 generate는 생산된 각 값을 연속적으로 계산하지 않는다. generate는 supplier<T>를 인수로 받아서 새로운 값을 생산한다.

Stream.generate(Math::random)
	  .limit(5)
	  .forEach(System.out::println);

generate는 우리가 사용한 발행자(supplier : 메서드 참조 Math.random)는 상태가 없는 메서드, 즉 나중에 계산에 사용할 어떤 값도 저장해두지 않는다.

하지만 발행자(supplier)가 반드시 상태가 없어야 하는 것은 아니다. 뒤에 부분에서 설명하겠지만 상태가 가능하게 코드를 작성할 수 있다. 그러나 병렬처리(동시성)에서 문제가 된다는 것을 알고 있어야 한다.

iterate에서 설명한 피보나치 수열 예제를 가져올 것이다. 추가적으로 박싱연산 문제를 해결하기 위해 IntStream을 사용할 것이며 IntStream은 Supplier<T> 대신 IntSupplier를 인수롤 받는다는 것을 기억하자.

IntSupplier은 익명 객체를 이용하여 다음과 같이 사용할 수 있다.

IntStreamtwos = IntStream.generate(new IntSupplier() { 
	public int getAsInt() { 
		return 2;
	}
});

이런식으로 IntSupplier을 커스터마이징하여 피보나치 수열을 구현해보자!

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

IntSupplier 객체의 상태는 가변상태이다. 인스턴스 필드에 값이 계속 변하기 때문이다. 앞에서 말했듯이 여러 쓰레드가 접근하였을 때 동시성 문제가 발생할 것이다.

반대로 iterate는 불변상태를 유지한다. 따라서 스트림을 병렬로 처리하면서 올바른 결과를 얻으려면 불변 상태 기법을 유지해야 한다. 이는 7장에서 배우도록 하자!

무한스트림에서는 limit이용해 명시적으로 스트림 크기를 제한 해야하며 무한 스트림의 요소는 무한적으로 계산이 반복되므로 정렬하거나 리듀스할수 없다.

참고자료)
본 포스팅은 모던 자바 인 액션을 참고하여 작성하였습니다.