자바 로드맵 강의/고급 3 - 람다, 스트림, 함수형 프로그래밍
스트림 API - 기능, 스트림 생성, 중간 연산 FlatMap, Optional 간단 설명, 최종 연산, 기본형 특화 스트림
소소한나구리
2025. 6. 21. 18:34
728x90
스트림 생성
스트림 정의 복습
스트림(Stream)은 자바 8부터 추가된 기능으로 데이터 처리에 있어서 간결하고 효율적인 코드 작성을 가능하게 해준다.
스트림을 이용하면 컬렉션이나 배열에 저장된 요소들을 반복문 없이도 간단하게 필터링(filter), 변환(map), 정렬(sorted) 등의 작업을 할 수 있다.
특히 중간 연산과 최종 연산을 구분하며 지연 연산(lazy evaluation)을 통해 불필요한 연산을 최소화하는데, 자바 스트림은 내부적으로 파이프라인 형태를 만들어 데이터를 단계별로 처리하고 결과를 효율적으로 반환한다.
스트림 생성 정리표
| 생성 방법 | 코드 예시 | 특징 |
| 컬렉션 | list.stream() | List, Set 등 컬렉션에서 스트림 생성 |
| 배열 | Arrays.stream(arr) | 배열에서 스트림 생성 |
| Stream.of(...) | Stream.of("a", "b", "c") | 직접 요소를 입력해 스트림 생성 |
| 무한 스트림(iterate) | Stream.iterate(0, n -> n + 2) | 무한 스트림 생성(초깃값 + 함수) |
| 무한 스트림(generate) | Stream.generate(Math::random) | 무한 스트림 생성(Supplier 사용) |
스트림 생성 예시
CreateStreamMain
package stream.operation;
public class CreateStreamMain {
public static void main(String[] args) {
System.out.println("1. 컬렉션으로부터 생성");
List.of("a", "b", "b")
.forEach(System.out::println);
System.out.println("2. 배열로부터 생성");
String[] arr = {"a", "b", "c"};
Arrays.stream(arr)
.forEach(System.out::println);
System.out.println("3. Stream.of() 사용");
Stream.of("a", "b", "c")
.forEach(System.out::println);
System.out.println("4. 무한 스트림 - iterate()");
// iterate: 초기값과 다음 값을 만드는 함수를 지정
Stream.iterate(0, n -> n + 2)
.limit(3) // 무한하게 반복되므로 limit을 지정
.forEach(System.out::println);
System.out.println("5. 무한 스트림 - generate()");
// generate: Supplier를 사용하여 무한하게 생성
Stream.generate(Math::random)
.limit(3)
.forEach(System.out::println);
}
}
/*
1. 컬렉션으로부터 생성
a
b
b
2. 배열로부터 생성
a
b
c
3. Stream.of() 사용
a
b
c
4. 무한 스트림 - iterate()
0
2
4
5. 무한 스트림 - generate()
0.7444801181073927
0.3492407643773062
0.4296587577631462
*/
컬렉션, 배열 Stream.of는 기본적으로 유한한 데이터 소스로부터 스트림을 생성한다.
iterate, generate는 별도의 종료 조건이 없으면 무한히 데이터를 만들어내는 스트림을 생성하기 때문에 필요한 만큼만 사용하도록 limit()을 사용해야 한다.
스트림은 일반적으로 한 번 사용하면 재사용할 수 없으므로 stream()으로 얻은 스트림을 여러 번 순회하려면 다시 스트림을 생성해야 한다.
중간 연산
중간 연산(Intermediate Operation)이란 스트림 파이프라인에서 데이터를 변환, 필터링, 정렬 등을 하는 단계이다.
여러 중간 연산을 연결하여 원하는 형태로 데이터를 가공할 수 있으며 결과가 즉시 생성되지 않고 최종 연산이 호출될 때 한꺼번에 처리된다는 특징이 있다(지연 연산)
중간 연산 정리표
| 연산 | 설명 | 예시 |
| filter | 조건에 맞은 요소만 남김 | stream.filter(n -> n > 5) |
| map | 요소를 다른 형태로 변환 | stream.map(n -> n * 2) |
| flatMap | 중첩 구조 스트림을 일차원으로 평탄화 | stream.flatMap(list -> list.stream()) |
| distinct | 중복 요소 제거 | stream.distinct() |
| sorted | 요소 정렬 | stream.sorted() stream.sorted(Comparator.reverseOrder()) |
| peek | 중간 처리(로그, 디버깅) | stream.peek(System.out::println) |
| limit | 앞에서부터 N개의 요소만 추출 | stream.limit(5) |
| takeWhile | 조건을 만족하는 동안 요소 추출(Java 9+) | stream.takeWhile(n -> n < 5) |
| dropWhile | 조건을 만족하는 동안 요소를 버리고 이후 요소 추출(Java 9+) | stream.dropWhile(n -> n < 5) |
중간 연산 예시
IntermediateOperationMain
package stream.operation;
public class IntermediateOperationMain {
public static void main(String[] args) {
List<Integer> numbers = List.of(1, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10);
// 1. filter
System.out.println("1. filter - 짝수만 선택");
numbers.stream()
.filter(n -> n % 2 == 0)
.forEach(n -> System.out.print(n + " "));
System.out.println("\n");
// 2. map
System.out.println("2. map - 각 숫자를 제곱");
numbers.stream()
.map(n -> n * n)
.forEach(n -> System.out.print(n + " "));
System.out.println("\n");
// 3. distinct
System.out.println("3. distinct - 중복 제거");
numbers.stream()
.distinct()
.forEach(n -> System.out.print(n + " "));
System.out.println("\n");
// 4. sorted
System.out.println("4. sorted - 기본 정렬");
Stream.of(8, 3, 6, 1, 9, 7, 8, 2, 4, 3)
.sorted()
.forEach(n -> System.out.print(n + " "));
System.out.println("\n");
// 5. sorted (커스텀 정렬)
System.out.println("5. sorted with Comparator - 내림차순 정렬");
Stream.of(8, 3, 6, 1, 9, 7, 8, 2, 4, 3)
.sorted(Comparator.reverseOrder())
.forEach(n -> System.out.print(n + " "));
System.out.println("\n");
// 6. peek
System.out.println("6. peek - 동작 확인용");
numbers.stream()
.peek(n -> System.out.print("before:" + n + ", "))
.map(n -> n * n)
.peek(n -> System.out.print("after:" + n + ", "))
.limit(5)
.forEach(n -> System.out.println("최종값: " + n));
System.out.println("\n");
// 7. limit
System.out.println("7. limit - 처음 5개 요소만");
numbers.stream()
.limit(5)
.forEach(n -> System.out.print(n + " "));
System.out.println("\n");
// 8. skip
System.out.println("8. skip - 처음 5개 요소를 건너뛰기");
numbers.stream()
.skip(5)
.forEach(n -> System.out.print(n + " "));
System.out.println("\n");
List<Integer> numbers2 = List.of(1, 2, 3, 4, 5, 1, 2, 3);
// 9. takeWhile (Java 9+), 정렬이 잘 되어있을 때 효과적
System.out.println("9. takeWhile - 5보다 작은 동안만 선택");
numbers2.stream()
.takeWhile(n -> n < 5)
.forEach(n -> System.out.print(n + " "));
System.out.println("\n");
// 10. dropWhile
System.out.println("10. dropWhile - 5보다 작은 동안 건너뛰기");
numbers2.stream()
.dropWhile(n -> n < 5)
.forEach(n -> System.out.print(n + " "));
System.out.println("\n");
}
}
/*
1. filter - 짝수만 선택
2 2 4 6 8 10
2. map - 각 숫자를 제곱
1 4 4 9 16 25 25 36 49 64 81 100
3. distinct - 중복 제거
1 2 3 4 5 6 7 8 9 10
4. sorted - 기본 정렬
1 2 3 3 4 6 7 8 8 9
5. sorted with Comparator - 내림차순 정렬
9 8 8 7 6 4 3 3 2 1
6. peek - 동작 확인용
before:1, after:1, 최종값: 1
before:2, after:4, 최종값: 4
before:2, after:4, 최종값: 4
before:3, after:9, 최종값: 9
before:4, after:16, 최종값: 16
7. limit - 처음 5개 요소만
1 2 2 3 4
8. skip - 처음 5개 요소를 건너뛰기
5 5 6 7 8 9 10
9. takeWhile - 5보다 작은 동안만 선택
1 2 3 4
10. dropWhile - 5보다 작은 동안 건너뛰기
5 1 2 3
*/
peek
- 중간 단계에서 요소를 엿보는 용도로 사용하며 데이터를 변경하지 않는다.
- 주로 디버깅이나 로깅 용도로 사용된다.
limit, skip
- limit: 앞에서부터 N개의 요소만 추출한다
- skip: 반대로 앞에서부터 N개의 요소를 건너뛰고 나머지 요소로 스트림을 구성한다
takeWhile, dropWhile
- Java 9이후에 나온 문법이다
- takeWhile: 입력된 조건을 만족하는 동안만 요소를 가져오며 조건이 처음으로 거짓이 되는 지점에서 스트림을 멈춘다.
- 스트림이 중간에 멈추기 때문에 원하는 목적을 빨리 달성하면 성능을 최적화 할 수 있다
- dropWhile: 반대로 조건을 만족하는 동안 요소를 버리고 조건이 처음으로 거짓이 되는 지점부터 스트림을 구성한다
- 이 두 기능은 정렬되지 않은 스트림에서 사용하면 예측하기 어렵기 때문에 정렬된 스트림에서 사용할 때 유용하다
중간 연산 정리
- 중간 연산은 파이프라인 형태로 연결할 수 있으며 스트림을 변경하지만 원본 데이터 자체를 바꾸지 않는다.
- 중간 연산은 lazy하게 동작하므로 최종 연산이 실행될 때까지 실제 처리는 일어나지 않는다.
FlatMap
map은 각 요소를 하나의 값으로 변환하지만 flatMap은 각 요소를 스트림(또는 여러 요소)으로 변환한 뒤 그 결과를 하나의 스트림으로 평탄화(flatten) 해준다
예를 들어 [ [1, 2], [3, 4], [5, 6] ] 처럼 리스트 안에 리스트가 있다고 가정할 때 FlatMap을 사용하면 [1, 2, 3, 4, 5, 6] 처럼 데이터를 쉽게 평탄화 할 수 있다.
예시 코드
MapVsFlatMapMain
package stream.operation;
public class MapVsFlatMapMain {
public static void main(String[] args) {
List<List<Integer>> outerList = List.of(
List.of(1, 2),
List.of(3, 4),
List.of(5, 6)
);
System.out.println("outerList = " + outerList);
// for - 평탄화
List<Integer> forResult = new ArrayList<>();
for (List<Integer> list : outerList) {
// forResult.addAll(list)도 가능함
for (Integer i : list) {
forResult.add(i);
}
}
System.out.println("forResult = " + forResult);
// map - 평탄화 안됨, 참조값이 출력됨
List<Stream<Integer>> mapResult = outerList.stream()
.map(List::stream)
.toList();
System.out.println("mapResult = " + mapResult);
// flatMap - 평탄화
List<Integer> flatMapResult = outerList.stream()
.flatMap(List::stream)
.toList();
System.out.println("flatMapResult = " + flatMapResult);
}
}
for문으로 평탄화를 처리하는 경우 이중 for문을 사용하거나 단일 반복문 안에서 forResult.addAll(list)를 사용해야 한다.
map을 사용하여 평탄화를 시도하면 이중 구조가 그대로 유지되어 List<Stream<Integer>>의 구조가 되고 참조값이 출력된다.
flatMap을 사용하면 내부의 Stream들을 하나로 합쳐 List<Integer>를 얻어 정상적으로 평탄화가 성공한다
map 동작 상세 설명
outerList.stream() 호출
- List<List<Integer>> ➡ Stream<List<Integer>>
- stream()을 호출하면 List<List<Integer>> 구조에서 가장 밖에 있는 List가 Stream으로 변하게 되어 스트림 내부에는 3개의 List<Integer> 요소가 존재하게 된다.
map(list -> list.stream())
- Stream<List<Integer>> ➡ Stream<Stream<Integer>>
- map(list -> list.stream())을 호출하면 내부에 있는 3개의 List<Integer>를 Stream<Integer>로 변환되고, 변환된 3개의 Stream<Integer>가 외부 stream에 포함된다
- 즉 구조가 Stream<Stream<Integer>>가 된다
toList()
- Stream<Stream<Integer>> ➡ List<Stream<Integer>>
- toList()는 스트림을 리스트로 변환하는데, 외부 스트림에 대해서만 실행하기 때문에 내부에 가지고 있는 Stream<Integer>는 변환되지 않는다.
- 따라서 내부 요소로 Stream<Integer> 3개를 가지고 있는 List<Stream<Integer>>의 구조로 변환된다.
결과적으로 List<Stream<Integer>>가 되어 기대한 결과가 나타나지 않는다.
중첩 컬렉션을 다룰 때는 map대신에 flatMap을 사용하면 편리하게 하나의 컬렉션으로 변환할 수 있다
flatMap 동작 상세 설명
outerList.stream() 호출
- 동일하게 Stream<List<Integer>>가 된다
flatMap(list -> list.stream())
- Stream<List<Integer>> ➡ Stream<Integer>
- flatMap(list -> list.stream())을 호출하면 내부에 있는 3개의 List<Integer>를 Stream<Integer>로 변환한다
- flatMap()은 변환된 각각의 Stream<Integer> 내부의 값을 모두 꺼내서 외부 Stream에 포함하여 하나의 Stream<Integer>가 된다
toList()
- Stream<Integer> ➡ List<Integer>
- 스트림을 리스트로 변환하면 최종적으로 List<Integer>가 된다
flatMap은 중첩 구조(컬렉션 안의 컬렉션, 배열 안의 배열 등)을 일차원으로 펼치는데 사용된다
예를 들어 문자열 리스트들이 들어있는 평탄화 하면 하나의 연속된 문자열 리스트로 편리하게 만들 수 있다.
Optional 간단 설명
여기서는 스트림의 최종 연산을 이해하는데 필요한 최소한의 옵셔널 기능을 알아보기 위해 매우 간단하게 Optional 클래스를 설명한다.
자바 Optional 클래스
package java.util;
public final class Optional<T> {
private final T value;
...
public boolean isPresent() {
return value != null;
}
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}
}
Optional은 내부에 하나의 값(value)를 가지며 isPresent()를 통해 그 값(value)이 있는지 없는지 확인할 수 있다.
get()을 통해 내부의 값을 꺼낼 수 있는데 만약 값이 없다면 예외가 발생한다.
Optional은 이름 그대로 필수가 아니라 옵션이라는 뜻으로 옵셔널 내부에 값이 있을 수도 있고 없을 수도 있다는 뜻이다.
코드 예시
OptionalSimpleMain
package stream.operation;
public class OptionalSimpleMain {
public static void main(String[] args) {
Optional<Integer> optional1 = Optional.of(10);
System.out.println("optional1 = " + optional1);
if (optional1.isPresent()) { // 값이 있는지 확인할 수 있는 안전한 메서드 제공
Integer i = optional1.get(); // Optional 안에 있는 값을 획득
System.out.println("i = " + i);
}
Optional<Object> optional2 = Optional.ofNullable(null);
System.out.println("optional2 = " + optional2);
if (optional2.isPresent()) {
Object o = optional2.get();
System.out.println("o = " + o);
}
// 값이 없는 Optional에서 get()을 호출하면 NoSuchElementException이 발생한다.
Object o2 = optional2.get();
System.out.println("o2 = " + o2);
}
}
/*
optional1 = Optional[10]
i = 10
optional2 = Optional.empty
Exception in thread "main" java.util.NoSuchElementException: No value present
at java.base/java.util.Optional.get(Optional.java:143)
at stream.operation.OptionalSimpleMain.main(OptionalSimpleMain.java:22)
*/
Optional은 내부에 값을 담아두고 그 값이 null인지 아닌지를 체크할 수 있는 isPresent()와 같은 안전한 체크 메서드를 제공한다.
그래서 해당 메서드를 통해 체크하고 난 다음에 값이 있을 때만 get()으로 값을 꺼내는 방식으로 코드를 작성할 수 있다
Optional은 null 값으로 인한 오류(NullPointerException)를 방지하고 코드에서 '값이 없을 수도 있다'는 상황을 명시적으로 표현하기 위해 사용된다.
즉 null을 직접 다루는 대신 Optional을 사용하면 값의 유무를 안전하게 처리할 수 있어 코드가 명확해지며 안정적으로 작성할 수 있게 된다.
스트림의 최종 연산에서 Optional을 사용하기에 최소한의 Optional 기능을 살펴 보았으나 Optional은 매우 다양한 기능을 제공하므로 이후에 매우 자세하게 다룰 예정이다.
최종 연산
최종 연산(Terminal Operation)은 스트림 파이프라인의 끝에 호출되어 실제 연산을 수행하고 결과를 만들어낸다.
최종 연산이 실행된 후에 스트림은 소모되어 더 이상 사용할 수 없다.
최종 연산 정리표
| 연산 | 설명 | 예시 |
| collect | Collector를 사용하여 결과 수집 (다양한 형태로 변환 가능) |
stream.collect(Collectors.toList()) |
| toList (Java 16+) | 스트림을 불변 리스트로 수집 | stream.toList() |
| toArray | 스트림을 배열로 변환 | stream.toArray(Integer[]::new) |
| forEach | 각 요소에 대해 동작 수행 (반환값 없음) | stream.forEach(System.out::println) |
| count | 요소 개수 반환 | long count = stream.count(); |
| reduce | 누적 함수를 사용하여 모든 요소를 단일 결과로 합침 초깃값이 없으면 Optional로 반환 |
int sum = stream().reduce(0, Integer::sum); |
| min / max | 최솟값, 최댓값을 Optional로 반환 | stream.min(Integer::compareTo) stream.max(Integer::compareTo) |
| findFirst | 조건에 맞는 첫 번재 요소를 Optional로 반환 | stream.findFirst() |
| findAny | 조건에 맞는 아무 요소나 Optional로 반환 | stream.findAny() |
| anyMatch | 하나라도 조건을 만족하는지, boolean 반환 | stream.anyMatch(n -> n > 5) |
| allMatch | 모두 조건을 만족하는지, boolean 반환 | stream.allMatch(n -> n > 0) |
| noneMatch | 하나도 조건을 만족하지 않는지, boolean 반환 | stream.noneMatch(n -> n < 0) |
코드 예시
TerminalOperationsMain
package stream.operation;
public class TerminalOperationsMain {
public static void main(String[] args) {
List<Integer> numbers = List.of(1, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10);
// Collectors는 뒤에서 더 자세히 다룸(복잡한 수집이 필요할 때 사용)
System.out.println("1. collect - List 수집");
List<Integer> evenNumbers1 = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println("짝수 리스트: " + evenNumbers1);
System.out.println();
System.out.println("2. toList() (Java 16+)");
List<Integer> evenNumbers2 = numbers.stream()
.filter(n -> n % 2 == 0)
.toList(); // 수정 불가능 리스트
System.out.println("짝수 리스트: " + evenNumbers2);
System.out.println();
System.out.println("3. toArray - 배열로 변환");
Integer[] array = numbers.stream()
.filter(n -> n % 2 == 0)
.toArray(Integer[]::new);
System.out.println("짝수 배열: " + Arrays.toString(array));
System.out.println();
System.out.println("4. forEach - 각 요소 처리");
numbers.stream()
.limit(5)
.forEach(n -> System.out.print(n + " "));
System.out.println("\n");
System.out.println("5. count - 요소 개수");
long count = numbers.stream()
.filter(n -> n > 5)
.count();
System.out.println("5보다 큰 숫자 개수: " + count);
System.out.println();
System.out.println("6. reduce - 요소들의 합");
System.out.println("초깃값이 없는 reduce");
Optional<Integer> sum1 = numbers.stream()
.reduce((a, b) -> a + b);
System.out.println("합계(초깃값 없음): " + sum1.get());
System.out.println("초깃값이 있는 reduce");
int sum2 = numbers.stream()
.reduce(100, (a, b) -> a + b);
System.out.println("합계(초깃값 100): " + sum2);
System.out.println();
System.out.println("7. min - 최솟값");
Optional<Integer> min = numbers.stream()
.min(Integer::compareTo);
System.out.println("최솟값: " + min.get());
System.out.println();
System.out.println("8. max - 최댓값");
Optional<Integer> max = numbers.stream()
.max(Integer::compareTo);
System.out.println("최댓값: " + max.get());
System.out.println();
System.out.println("9. findFirst - 첫 번째 요소");
Integer first = numbers.stream()
.filter(n -> n > 5)
.findFirst().get();
System.out.println("5보다 큰 첫 번째 숫자: " + first);
System.out.println();
// 멀티 스레드 상황에서 효과적
System.out.println("10. findAny - 아무 요소나 하나 찾기");
Integer any = numbers.stream()
.filter(n -> n > 5)
.findAny().get();
System.out.println("5보다 큰 아무 숫자: " + any);
System.out.println();
System.out.println("11. anyMatch - 조건을 만족하는 요소 존재 여부");
boolean hasEven = numbers.stream()
.anyMatch(n -> n % 2 == 0);
System.out.println("짝수가 있는지 여부: " + hasEven);
System.out.println();
System.out.println("12. allMatch - 모든 요소가 조건을 만족하는지");
boolean allPositive = numbers.stream()
.allMatch(n -> n > 0);
System.out.println("모든 숫자가 양수인지 여부: " + allPositive);
System.out.println();
System.out.println("13. noneMatch - 조건을 만족하는 요소가 없는지");
boolean noNegative = numbers.stream()
.noneMatch(n -> n < 0);
System.out.println("음수가 없는지 여부: " + noNegative);
}
}
/*
1. collect - List 수집
짝수 리스트: [2, 2, 4, 6, 8, 10]
2. toList() (Java 16+)
짝수 리스트: [2, 2, 4, 6, 8, 10]
3. toArray - 배열로 변환
짝수 배열: [2, 2, 4, 6, 8, 10]
4. forEach - 각 요소 처리
1 2 2 3 4
5. count - 요소 개수
5보다 큰 숫자 개수: 5
6. reduce - 요소들의 합
초깃값이 없는 reduce
합계(초깃값 없음): 62
초깃값이 있는 reduce
합계(초깃값 100): 162
7. min - 최솟값
최솟값: 1
8. max - 최댓값
최댓값: 10
9. findFirst - 첫 번째 요소
5보다 큰 첫 번째 숫자: 6
10. findAny - 아무 요소나 하나 찾기
5보다 큰 아무 숫자: 6
11. anyMatch - 조건을 만족하는 요소 존재 여부
짝수가 있는지 여부: true
12. allMatch - 모든 요소가 조건을 만족하는지
모든 숫자가 양수인지 여부: true
13. noneMatch - 조건을 만족하는 요소가 없는지
음수가 없는지 여부: true
*/
collect
- Collectors를 사용하여 다양한 형태로 결과를 수집(collect)한다.
- toList(), toSet(), Collectors.joining() 등 다양한 Collector를 제공하는데 뒤에서 자세히 다룬다
reduce
- 요소들을 하나의 값으로 누적한다 (합계, 곱, 최솟값, 최댓값 등)
- 초깃값을 주는 형태, 주지 않는 형태 두 가지가 있으며 초깃값이 없는 경우에는 Optional을 반환한다.
- 초기값이 없는데 스트림이 비어있는 경우 Optional(Optional.empty())를 반환한다.
findFirst, findAny
- findFirst: 조건에 맞는 첫 번째 요소를 반환한다
- findAny: 조건에 맞는 아무 요소나 반환한다(순서와 관계 없음)
- 병렬 스트림인 경우 findAny가 효율적으로 동작하며 그냥 사용하면 findFirst, findAny가 동일하다고 보면 된다
- 결과가 없을 수 있으므로 Optional을 통해 값 유무를 확인해야 한다
anyMatch, allMatch, noneMatch
- 스트림 요소 중 조건을 하나라도 만족하는지, 모두가 만족하는지, 아무것도 만족하지 않는지의 여부를 boolean으로 반환한다
최종 연산이 호출되면 그 동안 정의된 모든 중간 연산이 한 번에 적용되어 결과를 만든다
최종 연산을 한 번 수행하면 스트림은 재사용할 수 없다.
스트림은 컬렉션이나 배열을 사용하는데 있어 코드를 단순화 하고 다양한 데이터 처리 연산을 간결하게 표현할 수 있게 해주므로 상황에 맞는 중간 연산과 최종 연산을 적절히 조합하면 가독성과 유지보수성이 높은 코드를 작성할 수 있다.
기본형 특화 스트림
스트림 API에는 기본형(primitive) 특화 스트림이 존재하는데 각 기본 자료형에 특화된 기능을 사용할 수 있게 한다.
예를 들어 IntStream은 합계, 평균, 최솟값, 최댓값 등 정수와 관련된 연산을 좀 더 편리하게 제공하고 오토방식/언박싱 비용을 줄여 성능도 향상시킨다.
기본형 특화 스트림의 종류
| 스트림 타입 | 대상 원시 타입 | 생성 예시 |
| IntStream | int | IntStream.of(1, 2, 3), IntStream.range(1, 10), mapToInt(...) |
| LongStream | long | LongStream.of(10L, 20L), LongStream.range(1, 10), mapToLong(...) |
| DoubleStream | double | DoubleStream.of(3.14, 2.78), DoubleStream.generate(Math::random), mapToDouble(...) |
기본형 특화 스트림의 숫자 범위 생성 기능
- range(int startInclusive, int endExclusive): 시작값 이상, 끝값 미만
- IntStream.range(1, 5) -> [1, 2, 3, 4]
- rangeClosed(int startInclusive, int endInclusive): 시작값 이상, 끝값 포함
- IntStream.rangeClosed(1, 5) -> [1, 2, 3, 4, 5]
주요 기능 및 메서드
기본형 특화 스트림은 합계, 평균 등 자주 사용하는 연산을 편리한 메서드로 제공한다.
또한 타입 변환과 박싱/언박싱 메서드도 제공하여 다른 스트림과 연계해 작업하기 수월하다.
| 메서드/기능 | 설명 | 예시 |
| sum() | 모든 요소의 합계를 구함 | int total = IntStream.of(1, 2, 3).sum() |
| average() | 모든 요소의 평균을 구함 OptionalDouble을 반환 |
double ave = IntStream.range(1, 5) .average().getAsDouble(); |
| summaryStatistics() | 최솟값, 최대값, 합계, 개수, 평균 등이 담긴 IntSummaryStatistics(또는 Long/Double) 객체를 반환 |
IntSummaryStatistics stats = IntStream.range(1, 5).summaryStatistics(); |
| mapToInt(), mapToLong(), mapToDouble() |
결과 변환 매핑: int -> long 등등 | LongStream ls = IntStream.of(1, 2) .mapToLong(i -> i * 10L); |
| mapToObj() | 객체 스트림으로 변환: 기본형 -> 참조형 | Stream<String> s = IntStream.range(1, 5) .mapToObj(i -> "No: " + i); |
| asLongStream(), asDoubleStream() |
타입 변환 메서드: IntStream -> DoubleStream, LongStream |
LongStream longStream = IntStream.range(1, 5).asLongStream(); |
| boxed() | 기본형 특화 스트림을 박싱(Wrapper)된 객체 스트림으로 변환 |
Stream<Integer> si = IntStream.range(1, 5) .boxed(); |
| sum(), min() max(), count() |
합계, 최솟값, 최댓값, 개수를 반환 (타입 별로 int/long/double 반환) |
long cnt = LongStream.of(1, 2, 3) .count(); |
예시 코드
PrimitiveStreamMain
package stream.operation;
public class PrimitiveStreamMain {
public static void main(String[] args) {
// 기본형 특화 스트림 생성 (IntStream, LongStream, DoubleStream)
IntStream stream = IntStream.of(1, 2, 3, 4, 5);
stream.forEach(i -> System.out.print(i + " "));
System.out.println();
// 범위 생성 메서드 (IntStream, LongStream 가능)
IntStream range1 = IntStream.range(1, 6); // [1, 2, 3, 4, 5]
IntStream range2 = IntStream.rangeClosed(1, 6); // [1, 2, 3, 4, 5, 6]
System.out.print("range1 = ");
range1.forEach(i -> System.out.print(i + " "));
System.out.println();
System.out.print("range2 = ");
range2.forEach(i -> System.out.print(i + " "));
System.out.println();
// 1. 통계 관련 메서드 (sum, average, max, min, count)
// sum(): 합계 계산
int sum = IntStream.range(1, 6).sum();
System.out.println("sum = " + sum);
// average(): 평균값 계산
double avg = IntStream.range(1, 6)
.average()
.getAsDouble();
System.out.println("avg = " + avg);
// summaryStatistics(): 모든 통계 정보
IntSummaryStatistics stats = IntStream.range(1, 6).summaryStatistics();
System.out.println("합계 = " + stats.getSum()); // 15
System.out.println("평균 = " + stats.getAverage()); // 3.0
System.out.println("최댓값 = " + stats.getMax()); // 5
System.out.println("최솟값 = " + stats.getMin()); // 1
System.out.println("개수 = " + stats.getCount()); // 5
// 2. 타입 변환 메서드
// IntStream -> LongStream
LongStream longStream = IntStream.range(1, 5).asLongStream();
// IntStream -> DoubleStream
DoubleStream doubleStream = IntStream.range(1, 5).asDoubleStream();
// IntStream -> Stream<Integer>
Stream<Integer> boxedStream = IntStream.range(1, 5).boxed();
// 3. 기본형 특화 매핑
// int -> long
LongStream mappedLong = IntStream.range(1, 5)
.mapToLong(i -> i * 10L);
// int -> double
DoubleStream mappedDouble = IntStream.range(1, 5)
.mapToDouble(i -> i * 1.5);
// int -> 객체 변환 매핑
Stream<String> mappedObj = IntStream.range(1, 5)
.mapToObj(i -> "Number: " + i);
// 4. 객체 스트림 -> 기본형 특화 스트림으로 매핑
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
IntStream intStream = integerStream.mapToInt(i -> i);
// 5. 객체 스트림 -> 기본형 특화 스트림으로 매핑 활용
int result = Stream.of(1, 2, 3, 4, 5)
.mapToInt(i -> i)
.sum();
System.out.println("result = " + result);
}
}
/*
1 2 3 4 5
range1 = 1 2 3 4 5
range2 = 1 2 3 4 5 6
sum = 15
avg = 3.0
합계 = 15
평균 = 3.0
최댓값 = 5
최솟값 = 1
개수 = 5
result = 15
*/
기본형 특화 스트림을 이용하면 숫자 계산(합계, 평균, 최댓값, 최솟값 등)을 간편하게 처리하고 박싱/언박싱 오버헤드를 줄여 성능상의 이점도 얻을 수 있다.
range(), rangeClosed() 같은 메서드를 사용하면 범위를 쉽게 다룰 수 있어 반복문 대신에 자주 사용한다.
mapToXxx, boxed() 등의 메서드를 잘 활용하면 객체 스트림과 기본형 특화 스트림을 자유롭게 오가며 다양한 작업을 할 수 있고, summaryStatistics()를 이용하면 합계, 평균, 최솟값, 최댓값 등 통계 정보를 한 번에 구할 수 있어 편리하다.
기본형 특화 스트림을 잘 이용하면 가독성, 성능을 모두 잡을 수 있으므로 숫자 중심의 연산에는 적극 활용하는 것을 권장한다.
성능 - 전통적인 for문 vs 스트림 vs 기본형 특화 스트림
실제로 어느정도 차이가 나는지는 데이터의 양, 연산의 종류, JVM 최적화 등에 따라 달라지기 때문에 참고만 하면 된다
전통적인 for문이 보통 가장 빠른데, 일반적인 객체 스트림보다 전통적인 for문이 약 1.5배 ~ 2배정도 빠르다
객체를 다루는 Stream은 박싱/언박싱 오버헤드가 발생한다
기본형 특화 스트림은 기본형 특화 스트림은 박싱/언박싱 오버헤드를 피할 수 있고 내부적으로 최적화된 연산을 수행하기 때문에 전통적인 for문에 가까운 성능을 보여주며 전통적이 for문과 비교해보면 거의 비슷하거나 10% ~ 30%정도 느리다고 보면 된다.
실무 선택
- 이런 성능 차이는 대부분의 일반적인 애플리케이션에서는 거의 차이가 없으며 이런 차이를 느끼려면 한 번에 사용하는 루프가 최소한 수천만 건 이상이고 이러한 루프가 많이 반복되어야 한다
- 박싱/언박싱을 많이 유발하지 않는 상황이라면 일반 스트림과 기본형 특화 스트림 간 성능 차이는 그리 크지 않을 수 있다.
- 반면 대규모 데이터 처리나 반복 횟수가 많을 때는 기본형 스트림이 효과적일 수 있으며 성능 극대화가 필요한 상황에서는 여전히 for 루프가 더 빠른 경우가 많다.
- 결국 최적의 선택은 구현의 가독성과 유지보수성 등을 함께 고려해서 결정해야 하는데, 극단적인 성능이 필요한 경우가 아니라면 코드의 가독성과 유지보수성을 위해 스트림 API(스트림, 기본형 특화 스트림)를 사용하는 것이 보통 더 나은 선택이다
출처 : 인프런 - 김영한의 실전 자바 - 고급3편 (유료) / 김영한님
유료 강의이므로 정리에 초점을 두고 코드는 일부만 인용함
728x90