Stream(스트림)

<aside> 💡

스트림 객체에 내용을 복서하고 사용하는 것이기 때문에 원본의 내용은 바뀌지 않는다

복잡한 수식을 걸지 않아도 된다.

최종 연산을 하고나면 스트링 객체 사용 자체가 안됨.

</aside>

⇒ 스트림은 한번 사용하면 닫혀서 다시 사용할 수 없음 (재사용이 안됨)

→ 다시 사용하고싶다면 스트림을 다시 생성

strStream1.sorted().forEach(x->System.out.println(x)); 
//->이걸로 끝난 함수 (sorted : 정렬, forEach : 객체 하나씩 꺼내기)
int numOfStr = strStream1.count();
//-> 스트림이 닫혀서 에러발생함

스트림 사용 과정

생성하기 : 스트림 객체 생성
1. 배열을 통한 객체 생성
가공하기 : 필터링(filtering) 및 맵핑(mapping)등 원하는 결과를 만들어가는 중간작업
1. 가공을 해도 스트림형태이기 때문에 다시 컬랙션이나 배열로 받는 과정을 걸쳐야됨
결과만들기 : 최종적으로 결과를 만들어내는 작업
1. 결과 만든다는 얘기가 (2-a) 내용

스트림의 특징

<aside> 💡

—특징—

지연 연산 (Lazy Evaluation)

중간 연산은 최종 연산이 실행되기 전까지 아무 일도 하지 않는다
최종 연산이 호출될 때 까지 연기되는 처리방식이다.

중간연산

불변성( Immutable)

원본데이터는 변경하지 않는다

일획성

스트림은 최종연산이 끝나면 다시 중간 연산을 할 수 없다.

최종연산

스트림 파이프라인의 마지막에 실행되는 연산
스트림이 소비(consumed)되고, 실제 데이터가 처리된다
- 중간 연산들을 실행하게 하는 트리거이자 스트림의 결과를 만드는 연산
스트림을 종료시키며, 다시 사용할 수 없다.
값을 반환한다. </aside>

데이터를 하나씩 순회하면서 반복할거라면 iterator를 쓰면 되는데 왜 스트림을 써야하나?

데이터 처리 파이프라인을 구성해서 선언형으로 데이터를 처리할 수 있다.

//일반 반복
for(String name : names){
		if(name.length() > 3){
				System.out.println(name);
		}
}
//선언형
names.stream()
			.메서드()
			.메서드()
			.메서드()
			.메서드()
			
names.Stream().filter().map().forEach(); //체인처럼 연결한다

//내부 반복
//개발자가 반복을 제어하지 않고, 
//스트림이 알아서 요소들을 반복하면서 처리하는 방법
//어떻게 반복할지는 스트림이 정하고, 
//반복하면서 무엇을 할지를 정하면 된다. (forEach())

스트림 함수

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Ex02_Stream {
	public static void main(String[] args) {
		// 스트림의 중간연산
		// 주의: 중간 연산으로 끝맺음을 할 수 없음
		// 항상 최종연산으로 마무리를 해야함
		
		// filter()
		// 조건에 맞는 요소만 걸러냄
		List<String> list = Arrays.asList("apple", "banana", "avocado");
		list.stream()
			.filter(t -> t.startsWith("a"))
			.forEach(System.out::println);

		System.out.println("-------------------");

		// map()
		// 각 요소를 변환
		list.stream().map(t -> t.toUpperCase())// 대문자 변환
				.forEach(System.out::println);
		System.out.println("-------------------");

		// distinct()
		// 중복 제거
		Stream.of("a", "b", "a", "c")
			.distinct()
			.forEach(System.out::println);
		System.out.println("-------------------");

		// sorted() -> 오름차순 정렬
		Stream.of("banana", "apple", "cherry")
			.sorted()
			.forEach(System.out::println);
		System.out.println("-------------------");

		// limit()
		Stream.of(1, 2, 3, 4, 5)
			.limit(3)
			.forEach(System.out::println);
		System.out.println("-------------------");

		// skip()
		Stream.of(1, 2, 3, 4, 5)
			.skip(2)
			.forEach(System.out::println);
		System.out.println("-------------------");

		// peek()
		// 값을 그대로 유지하면서 중간에 볼 수 있게 해준다
		// 중간 디버깅용
		Stream.of("one", "two", "three")
				.peek(s -> System.out.println("peek : " + s))
				.map(String::toUpperCase)
				.forEach(System.out::println);
		System.out.println("-------------------");

	}
}

중간 연산	설명
Stream<T> distinct()	중복을 제거
Stream<T> filter(Predicate<T> predicate)	조건에 안 맞는 요소 제외
Stream<T> limit(long maxSize)	스트림의 일부를 잘라낸다
Stream<T> skip(long n)	스트림의 일부를 건너뛴다
Stream<T> peek(Consumer<T> action)	스트림의 요소에 작업 수행
Stream<T> sorted()Stream<T> sorted(Comparator<T> comparator)	스트림의 요소를 정렬한다.
Stream<R> map(Function<T,R> mapper)DoubleStream mapToDouble(ToDoubleFunction<T> mapper)IntStream mapToInt(ToIntFunction<T> mapper)Stream<R> flatMap(Function<T, Stream<R>> mapper)DoubleStream flatMapToDouble(Function<T, DoubleStream> m)IntStream flatMapToInt(Function<T, IntStream> m)LongStream flatMapToLong(Function<T, LongStream> m)	스트림의 요소를 변환한다.

sorted(Comparator)

⇒ 객체들을 합쳐주는 함수

Stream<String> strStream = Stream.of("banana", "apple","pinapple");
strStream.sort(Comparator.<String,String>comparing.(t -> t).reversed())
	.forEach(System.out::println);