[JAVA 8] 스트림(Stream)

Stream

java 8 이전에는 배열 또는 컬렉션을 순회하기 위해 for 또는 foreach문을 돌며 요소 하나씩 꺼내서 다루어야 했다.

stream을 활용하면 배열 또는 컬렉션에 함수 여러 개를 조합해서 필터링하거나 가공하여 원하는 결과를 얻을 수 있으며, 람다를 이용해 코드를 간결하게 표현할 수 있다. 또한 내부 반복자를 사용하므로 병렬처리가 쉽다.

 

• Stream은 원본 데이터 자체를 변경하지 않는다.
• Stream은 일회용으로 재사용이 불가능하다.
• Stream은 반복문을 내부에 숨기는 내부 반복으로 처리한다.

 

Stream 구조

객체.스트림생성().가공().결과();

중개 연산이 연산 결과를 stream으로 반환하기 때문에 연속적으로 사용할 수 있다.

1. 생성 : 스트림 인스턴스 생성
2. 중개 연산(가공하기) : filltering, mapping 등 원하는 결과를 만들어가는 중간 작업
3. 최종 연산(결과 만들기) : 최종적으로 결과를 만들어내는 작업

 

스트림은 데이터의 필터링, 매핑, 정렬, 그룹핑 등의 중간처리와 합계, 평균, 카운팅, 최댓값, 최솟값 등의 최종처리를 파이프라인으로 해결한다.

🧐 스트림 파이프라인
파이프라인은 한 데이터 처리 단계의 출력이 다음 단계의 입력으로 이어지는 형태로 연결된 구조이다.
스트림에는 필터링, 매핑, 정렬 등과 같은 많은 중간 처리 메소드가 있는데 이들은 중간 처리된 스트림을 리턴한다. 스트림 파이프라인은 지연 연산을 수행하여 최종 처리가 시작되기 전까지 중간 처리는 지연된다.

 

① Stream 생성

스트림을 사용할 수 있는 데이터 소스는 아래와 같다.

데이터 소스	설명
컬렉션	컬렉션의 조상인 Collection 인터페이스에 stream() 메소드가 정의되어 있음 parallelStream() 메소드를 사용하면 병렬 처리가 가능한 스트림을 생성할 수 있음
배열	Arrays 클래스에 stream() 메소드가 정의되어 있음 기본 타입인 int, long, double 형을 저장할 수 있는 스트림은 java.util.stream 패키지의 IntStream, LongStream, DoubleStream인터페이스로 제공됨
가변 매개변수	Stream 클래스의 of() 메소드를 사용하면 가변 매개변수로 스트림을 생성할 수 있음
지정된 범위의 연속된 정수	IntStream이나 LongStream 인터페이스에는 range()와 rangeClosed() 메소드가 정의되어 있음
특정 타입의 난수들	Random 클래스에는 ints(), longs(), doubles()와 같은 메소드가 정의되어 있음
람다 표현식	Stream 클래스에 iterate()와 generate() 메소드가 정의되어 있음
파일	java.nio.file.Files 클래스에는 lines() 메소드가 정의되어 있음
빈 스트림	아무 요소도 없는 스트림은 Stream 클래스의 empty() 메소드를 사용하여 생성할 수 있음

// 스트림 생성(스트림 빌더)
Stream<String> builderStream = Stream.<String>builder().add("A").add("B").add("C").build(); // A, B, C

// 컬렉션
List<String> list1 = Arrays.asList("A", "B", "C");

Stream<String> stream1 = list1.stream();
stream1.forEach(System.out::println);	// A, B, C

// 배열
String[] arr1 = new String[]{"A", "B", "C"};

Stream<String> stream2 = Arrays.stream(arr1);
stream2.forEach(System.out::println);	// A, B, C

Stream<String> stream3 = Arrays.stream(arr1, 1, 3);
stream3.forEach(System.out::println);	// 1~2 요소 A, B

// 가변 매개변수
Stream<Integer> stream4 = Stream.of(1, 2, 3, 4, 5);
stream4.forEach(System.out::println);	// 1, 2, 3, 4, 5

// 지정된 범위의 연속된 정수
IntStream intStream1 = IntStream.range(1, 5);
intStream1.forEach(x -> System.out.print(x + " "));	// 1 2 3 4

// 특정 타입의 난수
IntStream intStream2 = new Random().ints(4);
intStream2.forEach(System.out::println);	// random int 4개

// 람다 표현식
// iterate(): 초기 값과 해당 값을 다루는 람다를 이용해 스트림에 들어갈 요소를 만듦
Stream<Integer> iteratedStream = Stream.iterate(1, n -> n + 1).limit(5); // [1, 2, 3, 4, 5]
// generate(): Supplier<T>에 해당하는 람다로 값을 넣을 수 있음
Stream<String> generatedStream = Stream.generate(() -> "new item").limit(5); // [el, el, el, el, el]

// 파일
Stream<String> lineStream = Files.lines(Paths.get("fileName.txt"), Charset.forName("UTF-8"));

// 빈 스트림
Stream<Object> stream5 = Stream.empty();
System.out.println(stream5.count()); // 0

// 병렬 스트림
Stream<String> parallelStream = Arrays.asList(new String[]{"A", "B", "C"}).parallelStream();
boolean isParallel = parallelStream.isParallel();	// 병렬 여부 확인
parallelStream.map(x -> x + "-").anyMatch(y -> y == "A-");	// 병렬로 수행

 

② 중개 연산

연산	메소드
필터링	filter(), distinct()
변환	map(), flatMap()
제한	limit(), skip()
정렬	sorted()
연산 결과 확인	peek()

// filter(): 인자로 받는 Predicate는 boolean을 리턴하는 함수형 인터페이스가 들어감
List<String> list1 = Arrays.asList("Anna", "Erica", "Justin");
Stream<String> stream1 = list1.stream();
stream1.filter(n -> n.contains("a")).forEach(e -> System.out.print(e + " ");	// Anna Erica

// distinct()
IntStream stream2 = IntStream.of(1, 2, 3, 3);
stream2.distinct().forEach(e -> System.out.print(e + " "));	// 1 2 3

// map()
Stream<String> stream3 = Stream.of("A", "B", "C");
stream3.map(String::toLowerCase).forEach(System.out::println));	// a, b, c

// flatMap(): 중첩 구조를 한 단계 제거하고 단일 컬렉션으로 만들어줌
List<List<String>> list2 = Arrays.asList(Arrays.asList("A"), Arrays.asList("B"));
System.out.println(list2.stream().flatMap(Collection::stream).collect(Collectors.toList()));	// [A, B]

// skip(): 첫 번째 요소부터 전달된 개수만큼을 제외한 나머지 요소만으로 이루어진 새로운 스트림
// limit(): 첫 번째 요소부터 전달된 개수만큼의 요소만으로 이루어진 새로운 스트림
IntStream stream4 = IntStream.range(1, 10);	// 1, 2, 3, 4, 5, 6, 7, 8, 9
stream4.skip(3).limit(3).forEach(System.out::println);	// 4, 5, 6

// sorted()
// boxed(): int, long, double 요소를 Integer, Long, Double 요소로 박싱
IntStream.of(1, 3, 5, 4, 2).sorted().boxed().collect(Collectors.toList));	// [1, 2, 3, 4, 5]
IntStream.of(1, 3, 5, 4, 2).sorted(Comparator.reverseOrder()).boxed().collect(Collectors.toList));	// [5, 4, 3, 2, 1]

// peek(): 스트림 내 요소들 각각에 특정 작업을 수행
IntStream.of(1, 2, 3, 5, 4).peek(System.out::println).count();	// 1, 2, 3, 5, 4(결과는 5)

 

③ 최종 연산

연산	메소드
출력	forEach()
소모	reduce()
검색	findFirst(), findAny()
검사	anyMatch(), allMatch(), noneMatch()
통계	count(), min(), max()
연산	sum(), average()
수집	collect()

// forEach()
Stream<String> stream1 = Stream.of("A", "B", "C");
stream1.forEach(System.out::println);	// A, B, C

// reduce()
// - identity: 계산을 위한 초기 값
// - accumulator: 각 요소를 처리하는 계산 로직
// - combiner: 병렬 스트림에서 나눠 계산한 결과를 하나로 합침
Stream<String> stream2 = Stream.of("A", "B", "C");
stream2.reduce(">>>", (a, b) -> a + "-" + b);	// >>>A-B-C

// findFirst(): 가장 앞에 있는 요소 리턴
// findAny(): 가장 먼저 찾은 요소 리턴(병렬처리에서 차이가 있음)
IntStream stream3 = IntStream.of(1, 2, 3, 5, 4);
System.out.println(stream3.sorted().findFirst().getAsInt());	// 1, 정렬 후 첫 번째 요소 리턴

// collect()
Stream<String> stream4 = Stream.of("B", "A", "C");
List<String> list = stream4.collect(Collectors.toList());	// 스트림을 리스트로 변환, ["B", "A", "C"]

 

참고자료 및 출처 🙇‍♂️

https://ahndding.tistory.com/23

https://futurecreator.github.io/2018/08/26/java-8-streams/

http://www.tcpschool.com/java/java_stream_creation

https://beomseok95.tistory.com/217