[03] Stream

🌊 Stream

Stream이란 데이터 처리 연산을 지원하도록 소스에서 추출된 연속된 요소로 정의한다.

• 연속된 요소
  - Collection처럼 특정 요소 형식으로 이루어진 연속된 값 집합의 인터페이스를 제공한다.
• 소스
  - Collection, Array, I/O Resource 등의 데이터 제공 소스로부터 데이터를 소비한다.
• 데이터 처리 연산
  - 함수형 프로그래밍 언어에서 일반적으로 지원하는 연산과 데이터베이스와 비슷한 연산을 지원한다.

스트림의 2가지 중요 특징

1. Pipelining
   • 대부분의 Stream 연산은 Stream 연산끼리 연결해서 커다란 Pipeline을 구성할 수 있도록 Stream 자신을 반환한다.
   • Jaziness, short-circuiting 최적화를 얻을 수 있다.
2. 내부 반복
   • 반복자(Iterator)를 사용하는 Collection과 달리 내부 반복을 지원한다.

-- 칼로리가 가장 높은 순으로 3가지 요리
List<String> threeHighCaloricDishNames =
				menu.stream()
						.sorted(Comparator.comparingInt(Dish::getCalories).reversed())
						.map(Dish::getName)
						.limit(3)
						.collect(Collectors.toList());

---

🐾 Stream vs Collection

Collection과 Stream 모두 연속된 요소 형식의 값을 저장하는 자료구조의 Interface를 제공한다.

데이터를 언제 계산하는가?

• Collection은 현재 자료구조가 포함하는 모든 값을 메모리에 저장하는 자료구조이다.
  따라서, Collection의 모든 요소는 Collection에 추가하기 전에 계산(연산)되어야 한다.
• Stream은 요청하는 값(데이터)만 계산하는 고정된 자료구조이다.

단 1번만 탐색할 수 있다

• Collection의 Iterator(반복자)처럼 Stream도 1번만 탐색할 수 있다.
• 이미 1번 탐색한 요소를 다시 탐색하려면 데이터 소스에서 새로운 Stream을 만들어야 한다.

외부 반복과 내부 반복

-- Collection : for-each 외부 반복
List<String> names = new ArrayList<>();
for (Dish dish : menu) {
	names.add(dish.getName());
}

-- Collection : Iterator 외부 반복
List<String> names = new ArrayList<>();
Iterator<String> iterator = menu.iterator();
while (iterator.hasNext()) {
	Dish dish = iterator.next();
	names.add(dish.getName());
}

-- Stream : 내부 반복
List<String> names = menu.stream().map(Dish::getName).collect(toList());

---

🔬 Stream 연산

Stream의 연산은 두 그부으로 구분한다. 연결할 수 있는 Stream 연산을 중간 연산이라고 하며, Stream을 닫는 연산을 최종 연산이라고 한다.

중간 연산

Operator	Return Type	Functional Interface	Function Descriptor
filter	Stream<T>	Predicate<T>	T -> boolean
distinct	Stream<T>
takeWhile	Stream<T>	Predicate<T>	T -> boolean
dropWhile	Stream<T>	Predicate<T>	T -> boolean
skip	Stream<T>	long
limit	Stream<T>	long
map	Stream<R>	Predicate<T, R>	T -> R
flatMap	Stream<R>	Predicate<T, Stream<R>>	T -> Stream<R>
sorted	Stream<T>	Comparator<T>	(T, T) -> int

최종 연산

Operator	Return Type	Functional Interface	Function Descriptor
anyMatch	boolean	Predicate<T>	T -> boolean
noneMatch	boolean	Predicate<T>	T -> boolean
allMatch	boolean	Predicate<T>	T -> boolean
findAny	Optional<T>
findFirst	Optional<T>
forEach	void	Consumer<T>	T -> void
collect	R	Collector<T, A, R>
reduce	Optional<T>	BinaryOperator<T>	(T, T) -> T
count	long

---

🐇 Filtering

1. filter

Predicate를 인수로 받아서 일치하는 모든 요소를 포함하는 Stream을 반환한다.

List<Dish> vegetarianMenu = menu.stream().filter(Dish::isVegetarian).collect(toList());

2. distinct

고유 요소(hasCode, euqals)로 이루어진 Stream을 반환한다.

List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
numbers.stream().filter(i -> i % 2 == 0).distinct().forEach(system.out::println);

---

⚡ Stream Slicing

1. takeWhile, dropWhile

Java SE 9의 추가된 연산이며, 스트림의 요소를 효과적으로 선택한다.
요소들이 필터링 조건으로 정렬이 되어있는 경우에는 Predicate를 만족하는 영역 or Predicate를 만족하지 않는 영역으로 나눌 수 있다.

-- 칼로리로 정렬 되어 있는 List
List<Dish> specialMenu = Arrays.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)
);

-- filter 사용 ( 전체 요소에 Predicate 적용 후 반환)
List<Dish> filteredMenu = specialMenu.stream().filter(dish -> dish.getCalories() < 320).collect(toList());

-- takeWhile 사용 ( Predicate를 만족하지 않는 요소 첫번째 까지 수행 후 반환)
List<Dish> slicedMenu1 = specialMenu.stream().takeWhile(dish -> dis.getCalories() < 320).collect(toList());

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

2. limit

주어진 값(n) 이하의 크기를 갖는 새로운 Stream을 반환한다.

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

3. skip

처음 n개 요소를 제외한 Stream을 반환한다.

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

---

🍸 Mapping

1. map

Function을 인수로 받으며, Function은 각 요소에 적용되어 그 결과가 새로운 요소로 매핑된다.

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

2. flatMap

Function을 인수로 받으며, 배열이나 객체로 묶인 Stream을 단일 원소 Stream으로 반환한다.

String[] words = {"Hello", "world"};

-- map ( 결과 List<Stream<String>> : [("H","e","l","l","o"), ("w","o","r","l","d")])
words.stream()
	.map(word -> word.split(""))
	.map(Array::stream)
	.collect(toList());

-- flatMap ( 결과 List<String> : ["H","e","l","l","o","w","o","r","l","d"]
words.stream()
	.map(word -> word.split(""))
	.flatMap(Array::stream)
	.collect(toList());

---

🎡 Searching & Matching

1. anyMatch

Predicate를 인수로 받으며, 적어도 한 요소와 일치하는지 확인하여 boolean을 반환한다.

boolean isAnyMatch = menu.stream().anyMatch(Dish::isVegetarian);

2. allMatch, noneMatch

Predicate를 인수로 받으며, 모든 요소와 일치/불일치 하는지 확인하여 boolean을 반환하다.

-- 모두 일치
boolean isAllMatch = menu.stream().allMatch(Dish::isVegetarian);

-- 모두 불일치
boolean isNoneMatch = menu.stream().noneMatch(Dish::isVegetarian);

3. findAny

임의의 요소(Optional 객체)를 반환한다. Paralle Stream은 첫 번재 요소를 찾기 힘들기에 findAny를 사용한다.

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

4. findFirst

첫 번째 요소(Optional 객체)를 반환한다.

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();

---

🐝 Reducing

모든 Stream 요소를 처리해서 값으로 도출하는 것을 Reducing 연산이라고 한다.

reduce

두 개의 인수를 가질 수 있으며, 만약 첫번째 인수(초깃값)이 없으면 Optional 객체를 반환한다.

• 초깃값
• BinaryOperator<T>

-- 모든 값을 더하는 예제
int sum = 0;
for (int x : numbers) {
	sum += x;
}

-- reduce(초깃값, BinaryOperator<T\>)
int sum = numbers.stream().reduce(0, (sum, num) -> sum + num);

-- reduce(BinaryOperator<T\>)
Optional<Integer> sum = numbers.stream().reduce((sum, num) -> sum + num);

-- 최댓값
Optional<Integer> max = numbers.stream().reduce(Integer::max);

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

---

⛳ 기본형 특화 Stream

Stream API는 (Auto) Boxing을 피하기 위한 3가징 기본형 특화 Stream (IntStream, DoubleStream, LongStream)을 제공한다. 각각의 인터페이스는 자주 사용하는 숫자 관련 Reducing 연산 수행 메서드(sum, max 등)도 제공한다.

mapToInt, mapToDouble, mapToLong

Stream<T>을 기본형 특화 Stream (IntStream, DoubleStream, LongStream)으로 변환한다.

-- mapToInt (IntStream으로 변환)
int calories = menu.stream().mapToInt(Dish::getCalories).sum();

boxed

기본형 특화 Stream을 다시 Stream<T>으로 변환한다.

IntStream intStream = menu.stream().mapToInt(Dish::getCalories);
Stream<Integer> stream = intStream.boxed();

Reducing 연산

-- sum
int sum = menu.stream().mapToInt(Dish::getCalories).sum();

-- min (OptionalInt, OptionalDouble, OptionalLong 반환)
int min = menu.stream().mapToInt(Dish::getCalories).min().getAsInt();

-- max (OptionalInt, OptionalDouble, OptionalLong 반환)
int max = menu.stream().mapToInt(Dish::getCalories).max().getAsInt();

-- average (OptionalDouble 반환)
double average = menu.stream().mapToInt(Dish::getCalories).average().getAsDouble();

-- range (종료값 포함 하지 않음 : 49개)
IntStream evenNumbers1 = IntStream.range(1, 100).filter(n -> n % 2 == 0);
System.out.println(evenNumbers1.count());

-- rangeClosed (종료값 포함 : 50개)
IntStream evenNumbers2 = IntStream.rangeClosed(1, 100).filter(n -> n % 2 == 0);
System.out.println(evenNumbers2.count());

---

Making Stream

1. Stream.of

정적 메서드로써 임의의 수를 인수로 받아 Stream을 만든다.

Stream<String> stream = Stream.of("Hello", "world");
stream.map(s -> s.toUpperCase().split("")).flatMap(Arrays::stream).forEach(System.out::print);

-- 빈 Stream 만들기
Stream<String> emptyStream = Stream.empty();

2. Stream.ofNullable

Java SE 9의 추가된 정적 메서드로써 null이 될 수 있는 개체를 받아 Stream을 만든다.

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

3. Arrays.stream

정적 메서드로써 배열을 인수로 받아 Stream을 만든다.

-- 배열의 타입에 따라 IntStream, DoubleStream, LongStream을 반환한다.
int[] numbers = {2, 3, 5, 7, 11, 13};
int sum = Arrays.stream(numbers).sum();

double[] doubles = {0.1, 0.31, 4.7, 6.5, 10.0};
double sum2 = Arrays.stream(doubles).sum();

4. NIO API

파일 I/O 연산에 사용하는 NIO API도 Stream API를 활용할 수 있으며, java.nio.file.Files의 많은 정적 메서드가 Stream을 반환한다.

Stream 인터페이스는 AutoCloseable 인터페이스를 구현하므로, Try-with-resources 구문으로 자원을 자동으로 관리할 수 있다.

-- Files.lines : 파일의 각 행 요소를 반환한다.
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. Stream.iterate

정적 메서드로써 초기값과 UnaryOperator<T>를 인수로 받아서 무한 Stream (크기가 고정되지 않은 Stream)을 만든다.

-- iterate : UnaryOperator<T\>
Stream.iterate(new int[]{0, 1}, a -> new int[]{a[1], a[0] + a[1]})
		.limit(20)
		.forEach(t -> System.out.println("(" + t[0] + "," + t[1] + ")"));

Java SE 9에서는 Predicate<T>도 인수로 받아 언제까지 수행할 것인가에 대한 기준을 줄 수 있다.

-- iterate : Predicate<T\>, UnaryOperator<T\>
Stream.iterate(0, n -> n < 100, n -> n + 2)
		.forEach(System.out::println);

6. Stream.generate

정적 메서드로써 Supplier<T>를 인수로 받아서 무한 Stream을 만든다.

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

---