[Java 8] Stream API 기본 문법 및 활용 예제

 

 

 

 

 

Java 8의 Stream API는 데이터를 처리하고 변환하는 데 사용할 수 있는 강력한 기능을 제공합니다. 이 API를 사용하면 배열, 리스트, 맵 등의 컬렉션에서 데이터를 추출하고 필터링, 매핑, 집계 등 다양한 작업을 수행할 수 있습니다. 이번에는 Stream API의 기본 문법과 활용 예제를 알아보겠습니다.

 

 

---

#1. Stream 생성

Stream은 Collection, List, Set, Array 등의 자료구조로부터 생성될 수 있습니다. Stream을 생성하는 방법은 다음과 같습니다.

 

#1. 1. Collection으로부터 생성

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

 

#1. 2.  Array로부터 생성

String[] arr = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(arr);

 

#1. 3. Stream.of() 이용

Stream<String> stream = Stream.of("a", "b", "c");

 

 

 

---

#2. Stream 중간 연산

Stream에 대해서 중간 연산을 수행할 수 있습니다. 중간 연산은 Stream을 반환하기 때문에, 여러 개의 중간 연산을 연결하여 사용할 수 있습니다.

 

#2. 1. filter()

조건에 맞는 요소만을 선택하여 Stream으로 반환합니다.

Stream<String> stream = Stream.of("apple", "banana", "cherry", "durian");
Stream<String> filteredStream = stream.filter(str -> str.length() > 5);

 

#2. 2. map()

각 요소에 대해 매핑 함수를 적용하여 새로운 Stream을 반환합니다.

Stream<String> stream = Stream.of("apple", "banana", "cherry");
Stream<Integer> mappedStream = stream.map(str -> str.length());

 

#2. 3. flatMap()

각 요소에 대해 매핑 함수를 적용하여 새로운 Stream을 생성하고, 이를 하나의 Stream으로 병합하여 반환합니다.

Stream<List<Integer>> stream = Stream.of(Arrays.asList(1, 2), Arrays.asList(3, 4));
Stream<Integer> flatMappedStream = stream.flatMap(list -> list.stream());

 

#2. 4. sorted()

요소를 정렬하여 Stream으로 반환합니다.

Stream<String> stream = Stream.of("banana", "apple", "durian", "cherry");
Stream<String> sortedStream = stream.sorted();

 

#2. 5. distinct()

중복된 요소를 제거한 Stream을 반환합니다.

Stream<String> stream = Stream.of("apple", "banana", "apple", "cherry");
Stream<String> distinctStream = stream.distinct();

 

#2. 6. limit()

처리할 요소의 개수를 제한하여 Stream을 반환합니다.

Stream<String> stream = Stream.of("apple", "banana", "cherry", "durian");
Stream<String> limitedStream = stream.limit(2);

 

#2. 7. skip()

처리할 요소의 개수를 건너뛰고, 나머지 요소로 구성된 Stream을 반환합니다.

Stream<String> stream = Stream.of("apple", "banana", "cherry", "durian");
Stream<String> skippedStream = stream.skip(2);

 

 

 

---

#3. Stream 최종 연산

Stream에 대해서 최종 연산을 수행할 수 있습니다. 최종 연산은 Stream을 반환하지 않고, 최종 결과를 반환합니다.

 

#3. 1. forEach()

각 요소에 대해 작업을 수행합니다.

Stream<String> stream = Stream.of("apple", "banana", "cherry", "durian");
stream.forEach(str -> System.out.println(str));

 

#3. 2. toArray()

Stream의 요소를 배열로 반환합니다.

Stream<String> stream = Stream.of("apple", "banana", "cherry", "durian");
String[] arr = stream.toArray(String[]::new);

 

#3. 3. reduce()

Stream의 요소를 하나로 줄여 하나의 결과를 반환합니다.

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
int sum = stream.reduce(0, (acc, val) -> acc + val);

 

#3. 4. collect()

Stream의 요소를 수집하여 새로운 Collection, List, Set 등으로 반환합니다.

Stream<String> stream = Stream.of("apple", "banana", "cherry", "durian");
List<String> list = stream.collect(Collectors.toList());

 

#3. 5. count()

Stream의 요소의 개수를 반환합니다.

Stream<String> stream = Stream.of("apple", "banana", "cherry", "durian");
long count = stream.count();

 

#3. 6. anyMatch()

하나 이상의 요소가 조건에 맞는지 검사하여 결과를 반환합니다.

Stream<String> stream = Stream.of("apple", "banana", "cherry", "durian");
boolean result = stream.anyMatch(str -> str.startsWith("a"));

 

#3. 7. allMatch()

모든 요소가 조건에 맞는지 검사하여 결과를 반환합니다.

Stream<String> stream = Stream.of("apple", "banana", "cherry", "durian");
boolean result = stream.allMatch(str -> str.length() > 3);

 

#3. 8. noneMatch()

모든 요소가 조건에 맞지 않는지 검사하여 결과를 반환합니다.

Stream<String> stream = Stream.of("apple", "banana", "cherry", "durian");
boolean result = stream.noneMatch(str -> str.startsWith("z"));

300x250

 

 

---

#4. 활용 예제

 

스트림에서 요소 찾기

List<String> list = Arrays.asList("apple", "banana", "cherry");
Optional<String> result = list.stream().filter(s -> s.startsWith("a")).findFirst();
if (result.isPresent()) {
    System.out.println(result.get());
}

filter() 메서드를 사용하여 조건에 맞는 요소를 찾고 findFirst() 메서드를 사용하여 첫 번째 요소를 찾습니다. findFirst() 메서드는 Optional 인스턴스를 반환하므로, isPresent() 메서드로 결과가 존재하는지 확인한 후, get() 메서드로 결과를 가져옵니다.

 

 

스트림에서 요소 수집하기

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<String> result = list.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList());
System.out.println(result);

collect() 메서드를 사용하여 스트림에서 추출한 요소를 컬렉션으로 수집합니다. Collectors.toList() 메서드를 사용하여 리스트로 수집합니다.

 

 

스트림에서 요소 집계하기

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().reduce(0, Integer::sum);
System.out.println(sum);

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().reduce(0, (a, b) -> a + b);
System.out.println(sum);

**reduce()**메서드를 사용하여 스트림에서 요소를 연산할 수 있습니다. 위 예제에서는 reduce() 메서드를 사용하여 **list**스트림에서 모든 요소의 합을 계산한 후, 해당 합을 출력합니다. 이때, **reduce()**메서드의 첫 번째 인자는 초기값을 나타내며, 두 번째 인자는 각 요소를 처리하는 람다식입니다.

 

 

스트림에서 요소 그룹화하기

List<Person> people = Arrays.asList(
    new Person("John", 25),
    new Person("Jane", 30),
    new Person("Bob", 25),
    new Person("Alice", 30)
);
Map<Integer, List<Person>> result = people.stream().collect(Collectors.groupingBy(Person::getAge));
System.out.println(result);

groupingBy() 메서드를 사용하여 요소를 그룹화할 수 있습니다. 이 메서드는 그룹화 기준이 되는 함수를 인수로 받습니다. 위 예제에서는 Person 클래스에서 나이를 가져오는 getAge() 메서드를 사용하여 그룹화를 수행합니다. groupingBy() 메서드는 Map 인스턴스를 반환하므로, 결과를 출력하려면 System.out.println() 메서드를 사용합니다.

 

 

병렬 처리하기

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "eggfruit");
long count = list.parallelStream().filter(s -> s.startsWith("a")).count();
System.out.println(count);

parallelStream() 메서드를 사용하여 스트림을 병렬 처리할 수 있습니다. 병렬 처리를 사용하면 대용량 데이터를 빠르게 처리할 수 있습니다. 위 예제에서는 parallelStream() 메서드를 사용하여 스트림을 병렬 처리하고, filter() 메서드를 사용하여 "a"로 시작하는 요소를 추출한 후, count() 메서드를 사용하여 해당 요소의 수를 계산합니다.

이외에도 Stream API에서는 sorted(), distinct(), skip(), limit() 등 다양한 연산자가 제공됩니다. 이러한 연산자를 활용하여 데이터를 쉽게 처리할 수 있습니다.

 

 

Optional 활용하기

Optional<String> optional = Optional.of("Hello");
if (optional.isPresent()) {
    String result = optional.get();
    System.out.println(result);
} else {
    System.out.println("No value");
}

Optional 클래스는 null-safe한 연산을 수행할 때 사용됩니다. 위 예제에서는 Optional 클래스의 of() 메서드를 사용하여 "Hello" 문자열을 감싼 Optional 객체를 생성합니다. 그리고 isPresent() 메서드를 사용하여 해당 객체가 비어 있는지 여부를 확인합니다. 객체가 비어 있지 않으면 get() 메서드를 사용하여 해당 값을 가져와서 출력합니다.

 

 

Stream을 배열로 변환하기

List<String> list = Arrays.asList("apple", "banana", "cherry");
String[] array = list.stream().toArray(String[]::new);
System.out.println(Arrays.toString(array));

toArray() 메서드를 사용하여 스트림을 배열로 변환할 수 있습니다. 위 예제에서는 String 타입을 요소로 갖는 List 객체를 생성한 후, stream() 메서드를 사용하여 스트림으로 변환합니다. 그리고 toArray() 메서드를 사용하여 스트림을 String 타입의 배열로 변환합니다.

 

 

스트림의 모든 요소를 처리하기

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
list.forEach(System.out::println);

forEach() 메서드를 사용하여 스트림의 모든 요소를 처리할 수 있습니다. 위 예제에서는 Integer 타입을 요소로 갖는 List 객체를 생성한 후, forEach() 메서드를 사용하여 해당 요소를 출력합니다.

 

 

Stream에서 값 추출하기

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().mapToInt(Integer::intValue).sum();
System.out.println(sum);

스트림에서 값을 추출할 때는 mapToInt(), mapToLong(), **mapToDouble()**과 같은 메서드를 사용하여 원하는 형태로 변환한 후에 추출할 수 있습니다. 위 예제에서는 mapToInt() 메서드를 사용하여 Integer 타입을 int 타입으로 변환한 후에, sum() 메서드를 사용하여 모든 요소의 합을 구합니다.

 

 

Stream에서 중복 요소 제거하기

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 2, 4);
List<Integer> result = list.stream().distinct().collect(Collectors.toList());
System.out.println(result);

distinct() 메서드를 사용하여 스트림에서 중복 요소를 제거할 수 있습니다. 위 예제에서는 distinct() 메서드를 사용하여 중복된 **2**와 4 요소를 제거한 후, toList() 메서드를 사용하여 해당 요소를 포함하는 새로운 List 객체를 생성합니다.

 

 

Stream에서 요소를 분할하기

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Map<Boolean, List<Integer>> partitioned = list.stream().collect(Collectors.partitioningBy(i -> i % 2 == 0));
System.out.println(partitioned);

partitioningBy() 메서드를 사용하여 스트림에서 요소를 분할할 수 있습니다. 위 예제에서는 **partitioned**라는 Map 객체에 2로 나누어 떨어지는 요소와 아닌 요소를 분할한 결과를 저장합니다.

 

 

Stream에서 요소를 정렬하기

List<Integer> list = Arrays.asList(5, 3, 2, 1, 4);
List<Integer> sorted = list.stream().sorted().collect(Collectors.toList());
System.out.println(sorted);

sorted() 메서드를 사용하여 스트림에서 요소를 정렬할 수 있습니다. 위 예제에서는 sorted() 메서드를 사용하여 해당 스트림을 오름차순으로 정렬한 후, toList() 메서드를 사용하여 해당 요소를 포함하는 새로운 List 객체를 생성합니다.

 

 

Stream에서 요소를 제한하기

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> limited = list.stream().limit(3).collect(Collectors.toList());
System.out.println(limited);

limit() 메서드를 사용하여 스트림에서 요소를 제한할 수 있습니다. 위 예제에서는 limit() 메서드를 사용하여 해당 스트림에서 최대 3개의 요소만을 추출한 후, toList() 메서드를 사용하여 해당 요소를 포함하는 새로운 List 객체를 생성합니다.

 

 

Stream에서 요소를 건너뛰기

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> skipped = list.stream().skip(3).collect(Collectors.toList());
System.out.println(skipped);

skip() 메서드를 사용하여 스트림에서 요소를 건너뛸 수 있습니다. 위 예제에서는 skip() 메서드를 사용하여 해당 스트림에서 처음 3개의 요소를 건너뛴 후, 나머지 요소를 추출한 후 **toList()**메서드를 사용하여 해당 요소를 포함하는 새로운 **List**객체를 생성합니다.

 

 

Stream에서 요소를 매핑하기

List<String> words = Arrays.asList("hello", "world");
List<String> uniqueCharacters = words.stream().flatMap(s -> Arrays.stream(s.split("")))
                                                .distinct()
                                                .collect(Collectors.toList());
System.out.println(uniqueCharacters);

flatMap() 메서드를 사용하여 스트림에서 요소를 매핑할 수 있습니다. 위 예제에서는 flatMap() 메서드를 사용하여 words 리스트에서 각 문자열을 배열로 분할하고, 각 문자를 개별 요소로 만든 후 해당 요소를 포함하는 새로운 스트림을 생성합니다. 이후 distinct() 메서드를 사용하여 중복 요소를 제거한 후, toList() 메서드를 사용하여 해당 요소를 포함하는 새로운 List 객체를 생성합니다.

 

 

Stream에서 요소를 집계하기

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
IntSummaryStatistics stats = list.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println(stats);

summaryStatistics() 메서드를 사용하여 스트림에서 요소를 집계할 수 있습니다. 위 예제에서는 summaryStatistics() 메서드를 사용하여 list 스트림에서 요소의 합, 평균, 최대값, 최소값, 개수 등을 계산한 후, 해당 값을 포함하는 새로운 IntSummaryStatistics 객체를 생성합니다. 이후, 해당 객체를 출력합니다.

 

 

Stream에서 요소를 카운트하기

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
long count = list.stream().count();
System.out.println(count);

count() 메서드를 사용하여 스트림에서 요소를 카운트할 수 있습니다. 위 예제에서는 count() 메서드를 사용하여 list 스트림에서 요소의 개수를 계산한 후, 해당 개수를 출력합니다.

 

 

Stream에서 요소를 변환하기

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry", "fig");
List<String> transformedList = list.stream().map(s -> s.toUpperCase()).collect(Collectors.toList());
System.out.println(transformedList);

map() 메서드를 사용하여 스트림에서 요소를 변환할 수 있습니다. 위 예제에서는 map() 메서드를 사용하여 list 스트림에서 모든 문자열을 대문자로 변환한 후, 해당 요소를 포함하는 새로운 List 객체를 생성합니다.

 

 

 

---

마치며..

Java Stream API를 사용하여 데이터 처리를 더욱 쉽고 간결하게 처리되는 내용을 정리해 봤습니다. Stream의 다양한 기능을 활용하여 앞으로는 더 빠르고 품질 좋은 소스코드를 작성하는 좋은 개발자가 되도록 한 발자국 더 앞으로 나아가 보겠습니다. 많이 응원 부탁드릴게요. 😁