🦊 chap5. 스트림 활용

chap5. 스트림 활용

5.1 필터링

5.1.1 프레디케이트로 필터링

스트림 인터페이스는 filter 메서드를 지원한다.

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

List<Dish> vegetarianMenu = menu.stream()
																.filter(Dish::isVegetarian) // 채식 요리인지 확인하는 메서드 참조
																.collect(toList());

5.1.2 고유 요소 필터링

고유 요소로 이루어진 스트림을 반환하는 distinct 메서드를 지원한다.

고유 여부는 객체의 hashCode, equals 로 결정된다.

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 프레디케이트를 이용한 슬라이싱

자바 9는 스트림의 요소를 선택할 수 있도록 takeWhile, dropWhile 이라는 메서드를 지원한다.

TAKEWHILE 활용

takeWhile 을 이용하면 무한 스트림을 포함한 모든 스트림에 프레디케이트를 적용해 스트림을 슬라이스할 수 있다.

특히 리스트가 이미 정렬되어 있다는 사실을 이용해 반복 작업을 중단할 수 있다.

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

DROPWHILE 활용

dropWhile 은 takeWhile 의 정반대의 작업을 수행한다.

dropWhile 은 프레디케이트가 처음으로 거짓이 되는 지점까지 발견된 요소를 버린다.

그리고 남은 요소를 반환한다.

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

5.2.2 스트림 축소

주어진 값 이하의 크기를 갖는 새로운 스트림을 반환하는 limit(n) 메서드를 지원한다.

스트림이 정렬되어 있으면 최대 요소 n개를 반환할 수 있다.

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

프레디케이트와 일치하는 처음 세 요소를 선택한 다음에 즉시 결과를 반환한다.

5.2.3 요소 건너뛰기

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

n개 이하의 요소를 포함하는 스트림에서 호출하면 빈 스트림이 반환된다.

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

5.3 매핑

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

함수를 인수로 받는 map 메서드를 지원한다.

인수로 제공된 함수는 각 요소에 적용되며 그 결과가 새로운 요소로 매핑된다.

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

getName 은 문자열을 반환하기 때문에 map의 출력 스트림은 Stream<String> 형식을 갖는다.

List<String> words = Arrays.asList("Modern", "Java", "In", "Action");
List<Integer> wordLengths = words.stream()
																 .map(String::length)
																 .collect(toList());

각 단어가 포함하는 글자 수의 리스트를 반환한다.

List<Integer> dishNameLengths = menu.stream()
																		.map(Dish::getName)
																		**.map(String::length)**
																		.collect(toList());

이번엔 각 요리명의 길이를 포함하는 리스트를 반환한다.

5.3.2 스트림 평면화

리스트에서 고유 문자로 이루어진 리스트를 반환해보자.

[”Hello”, “World”] 리스트가 있다면 결과로 [”H”, “e”, “l”, “o”, “W”, “r”, “d”] 를 포함하는 리스트가 반환되어야 한다.

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

distinct 를 사용하여 문제를 해결하였지만 map 으로 전달한 람다는 String[] 을 반환한다는 점이 문제이다.

우리가 원하는 것은 문자열의 스트림을 표현할 Stream<String> 이다.

map과 Arrays.stream 활용

배열 스트림 대신 문자열 스트림이 필요하다.

문자열을 받아 스트림을 만드는 Arrrays.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());

결국 스트림 리스트가 만들어지면서 문제가 해결되지 않았다.

문제를 해결하려면 각 단어를 개별 문자열로 이루어진 배열로 만든 다음에 각 배열을 별도의 스트림으로 만들어야 한다.

flatMap 사용

flatMap 을 사용하면 문제를 해결할 수 있다.

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

flatMap 은 각 배열을 스트림이 아니라 스트림의 콘텐츠로 매핑한다.

즉 하나의 평면화된 스트림을 반환한다.

스트림의 각 값을 다른 스트림으로 만든 다음에 모든 스트림을 하나의 스트림으로 연결하는 기능을 수행한다.

5.4 검색과 매칭

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

anyMatch는 프레디케이트가 주어진 스트림에서 적어도 한 요소와 일치하는지 확인한다.

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

boolean 을 반환하기 때문에 최종 연산이다.

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

allMatch는 스트림의 모든 요소가 주어진 프레디케이트와 일치하는지 검사한다.

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

NONEMATCH

noneMatch 는 allMatch 와 반대 연산을 수행한다.

즉, 주어진 프레디케이트와 일치하는 요소가 없는지 확인한다.

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

이 세 가지 메서드는 스트림 쇼트서킷 기법을 활용한다.

전체 스트림을 저치하지 않았더라도 결과를 반환하는 것이다.

5.4.3 요소 검색

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

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

쇼트서킷을 이용해서 결과를 찾는 즉시 실행을 종료한다.

Optional이란?

Optional<T> 클래스는 값의 존재나 부재 여부를 표현하는 컨테이너 클래스이다.

null 이 쉽게 에러를 일으킬 수 있으므로 자바 8 라이브러리 설계자가 만들었다.

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

5.4.4 첫 번째 요소 찾기

일부 스트림에는 논리적인 아이템 순서가 정해져 있을 수 있다.

다음은 숫자 리스트에서 3으로 나누어 떨어지는 첫 번째 제곱값을 반환하는 코드이다.

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

findFirst와 findAny 는 언제 사용하나?

두 메서드가 왜 모두 필요한가?

바로 병렬성 때문이다.

병렬 실행에서는 첫 번째 요소를 찾기 어렵다.

따라서 요소의 반환 순서가 상관없다면 병렬 실행에서는 제약이 적은 findAny를 사용한다.

5.5 리듀싱

스트림 요소를 조합해서 더 복잡한 질의를 표현하는 방법을 리듀싱 연산이라고 한다.

함수형 프로그래밍 언어 용어로는 이 과정이 마치 종이를 작은 조각이 될 때까지 반복해서 접는 것과 비슷하다는 의미로 폴드(fold) 라고 부른다.

5.5.1 요소의 합

다음은 forEach 루프를 이용해서 리스트의 숫자 요소를 더하는 코드이다.

// 리스트의 숫자 요소의 합
int sum = 0;
for (int x : numbers) {
		sum += x;
}

nubmers 의 각 요소는 결과에 반복적으로 더해진다.

이 코드를 복사 붙여넣기 하지 않고 모든 숫자를 곱하는 연산을 구현할 수 있다면

다음처럼 reduce 를 이용해서 스트림의 모든 요소를 더할 수 있다.

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

reduce 는 두 요소를 인자로 가진다.

• 초깃값 0
• 두 요소를 조합해서 새로운 값을 만드는 BinaryOperator<T>

reduce 는 스트림의 요소를 소비하여 누적값으로 람다를 다시 호출한다.

초깃값 없음

초깃값을 받지 않도록 오버로드된 reduce 를 살펴보자.

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

스트림에 아무 요소도 없는 상황에선 초깃값이 없으므로 reduce 는 합계를 반환할 수 없다.

따라서 합계가 없음을 가리킬 수 있도록 Optional 로 감싼 결과를 반환한다.

5.5.2 최댓값과 최솟값

다음처럼 reduce를 이용해서 스트림의 최댓값과 최솟값을 찾을 수 있다.

Optional<Integer> max = numbers.stream().reduce(Integer::max);

Optional<Integer> min = numbers.stream().reduce(Integer::min);

5.6 실전 연습

1. 2011년에 일어난 모든 트랜잭션을 찾아 값을 오름차순으로 정리하시오.
2. 거래자가 근무하는 모든 도시를 중복 없이 나열하시오.
3. 케임브리지에서 근무하는 모든 거래자를 찾아서 이름순으로 정렬하시오.
4. 모든 거래자의 이름을 알파벳순으로 정렬해서 반환하시오.
5. 밀라노에 거래자가 있는가?
6. 케임브리지에 거주하는 거래자의 모든 트랜잭션값을 출력하시오.
7. 전체 트랜잭션 중 최댓값은 얼마인가?
8. 전체 트랜잭션 중 최솟값은 얼마인가?

5.7 숫자형 스트림

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

reduce 메서드로 스트림 요소의 합을 구하는 예제이다.

이 코드에는 박싱 비용이 숨어있다.

내부적으로 합계를 계산하기 전에 Integer 를 기본형으로 언박싱해야 한다.

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

최적화를 위해 sum 메서드를 직접 호출하고 싶지만 직접 호출은 불가능하다.

map 메서드는 Stream<T> 를 생성하기 때문이다.

스트림의 요소 형식은 Integer 이지만 인터페이스에는 sum 메서드가 없다.

다행히도 스트림 API 숫자 스트림을 효율적으로 처리할 수 있는 기본형 특화 스트림을 제공한다.

5.7.1 기본형 특화 스트림

자바 8에서는 세 가지 기본형 특화 스트림을 제공한다.

• IntStream
• DoubleStream
• LongStream

특화 스트림은 오직 박싱 과정에서 일어나는 효율성과 관련 있으며 스트림에 추가 기능을 제공하지는 않는다.

숫자 스트림으로 매핑

스트림을 특화 스트림으로 변환할 때는 mapToInt mapToDouble mapToLong 세 가지 메서드를 가장 많이 사용한다.

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

mapToInt 는 모든 Integer 형식 칼로리를 추출한 다음에 IntStream 을 반환한다.

따라서 IntStream 에서 제공하는 sum 메서드를 이용해서 칼로리 합계를 계산할 수 있다.

스트림이 비어있다면 기본값 0을 반환한다.

객체 스트림으로 복원하기

숫자 스트림을 만든 다음에 원상태인 특화되지 않은 스트림으로 복원할 수 있다.

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

기본값 : OptionalInt

합계에서는 0이라는 기본값이 있기 때문에 문제가 없지만

IntStream 에서 최댓값을 찾을 때는 0이라는 기본값 때문에 잘못된 결과가 도출될 수 있다.

스트림에 요소가 없는 상황을 구별할 수 있도록 Optioanl 참조 형식으로 파라미터화 할 수 있다.

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

OptionalInt OptionalDouble OptionalLong 세 가지 기본형 특화 스트림 버전을 제공한다.

int max = maxCalories.orElse(1); // 값이 없을 때 기본 최댓값을 명시적으로 설정 

5.7.2 숫자 범위

특정 범위의 숫자를 이용해야 하는 상황이 자주 발생한다.

자바 8의 IntStream 과 LongStream 에서는 range 와 rangeClosed 라는 정적 메서드를 제공한다.

range 는 시작값과 종료값이 결과에 포함되지 않는 반면

rangeClosed 는 시작값과 종료값이 결과에 포함된다는 점이 다르다.

IntStream evenNumbers = IntStream.rangeClosed(1, 100) // [1, 100] 범위
																 .filter(n -> n % 2 == 0); // 짝수 스트림
System.out.println(evenNumbers.count());

이 코드는 1부터 100까지의 숫자를 만들고 짝수만 필터링한 후 짝수 50개를 반환한다.

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

세 수 표현하기

세 요소를 갖는 int 배열을 사용한다. 예를 들면 (3,4,5) 를 new int[]{3, 4, 5} 로 표현할 수 있다.

좋은 필터링 조합

피라고라스 공식을 만족하는 코드를 다음과 같이 구현한다.

Math.sqrt(a*a + b*b) % 1 == 0

filter(b -> Math.sqrt(a*a + b*b) % 1 == 0)

집합 생성

이제 마지막 세 번째 수를 찾아야 한다.

map 을 사용해서 각 요소를 피타고라스 수로 변환할 수 있다.

stream.filter(b -> Math.sqrt(a*a + b*b) % 1 == 0)
			**.map(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)});**

b값 생성

Stream.rangeClosed 로 주어진 범위의 수를 만들 수 있다.

**IntStream.rangeClosed(1, 100)**
				 .filter(b -> Math.sqrt(a*a + b*b) % 1 == 0)
				 .**boxed()**
				 ****.map(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)});

개체값 스트림을 반환하는 IntStream 의 mapToObj 메서드를 이용해서 재구현 한다.

IntStream.rangeClosed(1, 100)
****				 .filter(b -> Math.sqrt(a*a + b*b) % 1 == 0)
				 **.mapToObj**(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)});

a값 생성

마지막으로 a값을 생성하는 코드를 추가하여 완성한다.

Stream<int[]> pythagoreanTriples =
		IntStream.rangeClosed(1, 100).boxed()
						 .flatMap(a ->
								 IntStream.rangeClosed(a, 100)
													.filter(b -> Math.sqrt(a*a + b*b) % 1 == 0)
													.mapToObj(b -> new int[]{a, b, (int)Math.sqrt(a*a+b*b)})
						 );

코드 실행

limit 을 이용해서 얼마나 많은 세 수를 포함하는 스트림을 만들 것인지만 결정하면 된다.

pythagoreamTriples.limit(5)
									.forEach(t -> 
											System.out.println(t[0] + ", " + t[1] + ", " + t[2]));

개선할 점 ?

현재 코드에서는 제곱근을 두 번 계산한다.

따라서 세 수를 만든 다음에 우리가 원하는 조건에 맞는 결과만 필터링하는 것이 더 최적화된 방법이다.

Stream<double[]> pythagoreanTriples2 =
		IntStream.rangeClosed(1, 100).boxed()
						 .flatMap(a -> IntStream.rangeClosed(a, 100)
						 .mapToObj(
								 b -> new double[]{a, b, Math.sqrt(a*a + b*b)}) // 만들어진 세 수
						 .filter(t -> t[2] % 1 == 0); // 세 수의 세 번째 요소는 반드시 정수여야 한다.

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 이 될 수 있는 개체를 스트림으로 만들 수 있는 새로운 메서드가 추가되었다.

예를 들어 System.getProperty 는 키에 대응되는 속성이 없으면 null 을 반환한다.

이런 메서드를 스트림에 활용하려면 다음처럼 null 을 명시적으로 확인해야 했다.

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

Stream.ofNullable 을 이용해 다음처럼 구현 가능하다.

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](http://Arrays.stream) 을 이용해서 배열을 스트림으로 만들 수 있다.

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

5.8.4 파일로 스트림 만들기

파일을 처리하는 등의 I/O 연산에 사용하는 자바의 NIO API도 스트림 API을 활용할 수 있다.

long uniqueWords = 0;
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) {
	// 파일을 열다가 예외가 발생하면 처리한다.
}

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

함수에서 스트림을 만들 수 있는 두 정적 메서드 Stream.iterate 와 Stream.generate 를 제공한다.

이 스트림은 요청할 때마다 주어진 함수를 이용해서 값을 만든다.

따라서 무제한으로 값을 계산할 수 있다.

보통 무한한 값을 출력하지 않도록 limit(n) 함수를 연결해서 사용한다.

iterate 메서드

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

iterate 메서드는 초깃값과 람다를 인수로 받아서 새로운 값을 끊임없이 생산할 수 있따.

예제에서는 람다로 인해 이전 결과에 2를 더한 값을 반환한다.

즉 짝수 스트림을 생성한다.

iterate 는 요청할 때 마다 값을 생산하고 끝이 없으므로 무한 스트림을 만든다.

이러한 스트림을 언바운드 스트림이라고 표현한다.

바로 이런 특징이 스트림과 컬렉션의 큰 차이점이다.

자바 9의 iterate 메서드는 프레디케이트를 지원한다.

이 코드는 0에서 시작해서 100보다 크면 숫자 생성을 중단하는 코드이다.

// 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 메서드

generate 메서드도 요구할 때 값을 계산하는 무한 스트림을 만들 수 있다.

하지만 생산된 각 값을 연속적으로 계산하지 않는다.

generate 는 Supplier<T> 를 인수로 받아서 새로운 값을 생산한다.

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

이 코드는 0에서 1사이의 임의의 Double 형 숫자 다섯 개를 만든다.

0.9410810294106129
0.6586270755634592
0.9592859117266873
0.13743396659487006
0.3942776037651241

이번에도 명시적으로 limit 메서드를 사용하여 스트림의 크기를 한정했다.

limit 이 없다면 스트림은 언바운드 상태가 된다.

generate는 언제 사용할까?

generate는 상태가 없는 메서드, 즉 나중에 계산할 어떤 값도 저장하지 않는 메서드를 활용한다.

병렬 코드에서는 발행자(Supplier)에 상태가 있으면 안전하지 않다.

IntStream을 이용하면 박싱 연산 문제를 피할 수 있었다.

IntStream의 generate 메서드는 Supplier<T> 대신에 IntSupplier를 인수로 받는다.

IntStream ones = IntStream.generate(() -> 1);

람다로 함수형 인터페이스의 인스턴스를 바로 만들어 전달할 수 있었다.

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

generate 메서드는 주어진 Supplier 를 활용해서 2를 반환하는 getAsInt 메서드를 반복적으로 호출할 것이다.

익명 클래스와 람다는 비슷한 연산을 수행하지만 익명 클래스에서는 메서드의 연산을 커스터마이즈할 수 있다는 점이 다르다.

바로 부작용이 생길 수 있다는 점을 보여준다.

피보나치 수열 작업에서 기존 수열 상태를 저장하고 getAsInt 로 다음 요소를 게산하도록 IntSupplier를 만들어야 한다. 또 다음에 호출될 때는 IntSupplier 의 상태를 갱신할 수 있어야 한다.

// 피보나치 요소를 반환하도록 IntSupplier 구현
IntSupplier fib = 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 인스턴스는 가변 상태 객체이다.

getAsInt 를 호출하면 객체 상태가 바뀌며 새로운 값을 생산한다.

iterate를 사용했을 때는 기존 상태를 바꾸지 않고 새로운 값을 생성하는 순수한 불편 상태를 유지했다.

스트림을 병렬로 처리하면서 올바른 결과를 얻으려면 불변 상태 기법을 고수해야 한다.

무한 스트림에서는 limit 을 이용해서 명시적으로 스트림 크기를 제한해야 한다.

그렇지 않으면 아무 결과도 계산되지 않는다.

마찬가지로 무한적으로 계산이 반복되므로 정렬하거나 리듀스 할 수 없다.