[자바/Java] 스트림 Stream - 심화
스트림 Stream 심화
이전까지는 스트림의 생성 - 중간 연산 -최종 연산으로 이어지는 기본 개념 및 사용방법에 대해서 다루었다. 이번 글에서는 더 나아가 스트림의 동작 순서, 성능 향상 등 더 깊은 내용에 대해 다루겠다.
- 동작 순서
- 성능 향상
- 스트림 재사용
- 지연 처리
- Null-safe 스트림 생성
- 줄여쓰기
동작순서
스트림은 데이터의 흐름이다. 이때에 데이터의 흐름이 생성과 중간 연산, 최종 연산을 거쳐 흐르게 되는데, 구체적으로 어떻게 흐르는지에 대한 관찰이 필요하다.
다음 예제에서, 출력 결과는 어떻게 될까?
List<String> list = Arrays.asList("Eric", "Elena", "Era");
list.stream()
.filter(el -> {
System.out.println("filter() was called");
return el.contains("a");
})
.map(el -> {
System.out.println("map() was called.");
return el.toUpperCase();
})
.findFirst(); //strea에서 제일 첫번째 요소 반환대부분의 사람이 filter가 3번 동작 -> map이 2번 동작 -> findFirst 의 순서로 동작한다고 생각할 것이다. 하지만 stream에서 연산은 모든 요소가 하나의 중간 연산을 수행하고 다음 연산으로 넘어가는 것이 아닌 하나의 요소가 모든 파이프라인을 통과해서 결과를 만들어 낸 뒤, 다음 요소로 넘어간다.
위의 예시를 단계별로 나타내면 아래와 같다.
- Eric -> filter 중간 연산 -> filter() was called 출력 -> "a"를 포함하지 않으므로 다음 연산 수행X
- Elena -> filter 중간 연산 -> filter() was called 출력 -> "a"를 포함하여 다음 연산 수행O
- Elena -> map 중간 연산 -> map() was called 출력 -> ELENA 를 다음 연산으로 넘김
- 최종 연산 stream에 ELENA가 들어감 -> findFirst -> 첫번째 요소인 ELENA반환 -> 종료
- Era에 대해서는 연산을 진행하지 않음
즉, filter -> filter -> map -> findFirst 순의 동작 순서를 가지는 것이다. 마지막 "Era"에 대한 연산은 이미 Elena에 대한 연산의 결과가 최종 연산의 결과이므로 더 이상 진행되지 않는 것이다.
성능 향상
위에서 살펴봤듯이 스트림은 한 요소씩 수직적으로 실행되는데, 여기에 스트림의 성능을 개선할 수 있는 힌트를 발견할 수 있다.
아래의 예제를 살펴보면,
List<String> list = Arrays.asList("Eric", "Elena", "Stream");
list.stream()
.map(el -> el.substring(0, 3)
.skip(2) //3번째 요소부터 끝까지
.collect(Collectors.toList());동작 순서가 아래와 같다.
- Eric -> map -> skip
- Elena -> map -> skip
- Stream -> map -> skip -> collect
첫번째 요소인 Eric, Elena는 skip으로 인해서 어차피 최종 연산까지 도달하지 못한다. 사실상 의미없는 데이터인 것이다. 하지만 위의 예제에서는 의미없는 데이터에 map을 통해 substring 작업을 진행하는 것을 볼 수 있다.
이러한 불필요한 작업은 중간 연산의 순서를 변경함으로써 해결할 수 있다.
List<String> list = Arrays.asList("Eric", "Elena", "Stream");
list.stream()
.skip(2) //3번째 요소부터 끝까지
.map(el -> el.substring(0, 3)
.collect(Collectors.toList());이렇게 변경할 경우, 다음과 같은 동작 순서를 가진다.
- Eric -> skip
- Elena -> skip
- Stream -> skip -> map -> collect
훨씬 적은 연산으로 위의 예제와 같은 결과가 나오는 것이다. 이렇듯, 스트림에서 성능을 향상시키기 위해서는 불필요한 연산을 줄여야 하고 이러한 방법 중 하나가 요소의 범위를 줄이는 작업을 먼저 진행한 것이다.
이러한 작업에는 skip, filter, distinct 등이 있다.
스트림 재사용
스트림은 종료 작업을 하지 않는 한 하나의 객체로서 계속해서 사용을 할 수 있다. 하지만 종료 연산을 하는 순간 스트림이 닫히기 때문에 재사용은 불가능하다.(스트림은 데이터를 저장하려는 용도X)
아래의 예제는 스트림이 닫혔는데, 스트림을 사용하는 경우이다.(에러 발생!!)
Stream<String> stream =
Stream.of("Eric", "Elena", "Java")
.filter(name -> name.contains("a"));
Optional<String> firstElement = stream.findFirst();
Optional<String> anyElement = stream.findAny(); // IllegalStateException: stream has already been operated upon or closed
이러한 상황이 발생하지 않게 하기 위해서는 데이터를 List에 저장하고 필요할 때마다 스트림을 생성하여 사용하면 된다.
List<String> names =
Stream.of("Eric", "Elena", "Java")
.filter(name -> name.contains("a"))
.collect(Collectors.toList());
Optional<String> firstElement = names.stream().findFirst();
Optional<String> anyElement = names.stream().findAny();
지연 처리 (Lazy Invocation)
스트림에서 최종 결과는 최종 연산이 이루어질 때 계산된다. 다음은 호출 횟수를 카운트 하는 예제이다.
private long counter;
private void wasCalled() { counter++; }
List<String> list = Arrays.asList("Eric", "Elena", "Java");
counter = 0;
Stream<String> stream = list.stream()
.filter(el -> {
wasCalled();
return el.contains("a");
});
System.out.println(counter); // 0 ??위의 예제의 결과는 3이 나올거라는 예상과는 다르게 0이 나온다. 그 이유로는, 스트림의 최종 연산이 실행되지 않으면 스트림의 연산 또한 실행되지 않기 때문이다.
이러한 경우, 최종 연산을 수행을 해 주면 제대로 동작하는 것을 알 수 있다.
list.stream().filter(el -> {
wasCalled();
return el.contains("a");
}).collect(Collectors.toList());
System.out.println(counter); // 3
Null-sate 스트림 생성하기
NPE(NullPointerException)은 개발 시 흔히 발생하는 예외이다. Optional을 이용해서 null에 안전한(null-safe) 스트림을 생성할 수 있다.
public <T> Stream<T> collectionToStream(Collection<T> collection) {
return Optional
.ofNullable(collection)
.map(Collection::stream)
.orElseGet(Stream::empty);
}위의 코드는 인자로 받은 컬렉션 객체를 이용해 옵셔널 객체를 생성하고 스트림을 생성한 후 리턴하는 메소드이다. 만약 컬렉션이 비어있는 경우 빈 스트림을 리턴한다.
List<Integer> intList = Arrays.asList(1, 2, 3);
List<String> strList = Arrays.asList("a", "b", "c");
//null이 아닐 때
Stream<Integer> intStream =
collectionToStream(intList); // [1, 2, 3]
Stream<String> strStream =
collectionToStream(strList); // [a, b, c]
//null인 경우, 위에서 만든 메소드 사용
List<String> nullList = null;
collectionToStream(nullList)
.filter(str -> str.contains("a"))
.map(String::length)
.forEach(System.out::println); // []
줄여 쓰기 (Simplified)
스트림 사용 시 다음과 같은 경우에는 내용을 좀 더 간결하게 줄여 쓸 수 있다. IntelliJ를 사용하면 줄여쓸 것을 제안해준다.
collection.stream().forEach()
→ collection.forEach()
collection.stream().toArray()
→ collection.toArray()
Arrays.asList().stream()
→ Arrays.stream() or Stream.of()
Collections.emptyList().stream()
→ Stream.empty()
stream.filter().findFirst().isPresent()
→ stream.anyMatch()
stream.collect(counting())
→ stream.count()
stream.collect(maxBy())
→ stream.max()
stream.collect(mapping())
→ stream.map().collect()
stream.collect(reducing())
→ stream.reduce()
stream.collect(summingInt())
→ stream.mapToInt().sum()
stream.map(x -> {...; return x;})
→ stream.peek(x -> ...)
!stream.anyMatch()
→ stream.noneMatch()
!stream.anyMatch(x -> !(...))
→ stream.allMatch()
stream.map().anyMatch(Boolean::booleanValue)
→ stream.anyMatch()
IntStream.range(expr1, expr2).mapToObj(x -> array[x])
→ Arrays.stream(array, expr1, expr2)
Collection.nCopies(count, ...)
→ Stream.generate().limit(count)
stream.sorted(comparator).findFirst()
→ Stream.min(comparator)
이러한 간략하게 표기하는 방법은 상황에 따라 다르게 동작할 수 있으니 주의하여야 한다.