[Java] Stream(스트림) API 사용방법, 예제

아래 예제 코드는 Java Stream API를 사용하여 데이터를 변환하고 필터링하는 다양한 방법을 작성하였습니다.
Stream API를 사용하면 컬렉션 데이터를 함수형 스타일로 간결하게 처리할 수 있습니다. 

 

 

Java Stream API

Java 8에서 도입된 기능으로, 데이터 컬렉션을 처리하고 변환하는 효율적이고 간결한 방법을 제공합니다. 
Stream API를 사용하면 데이터를 필터링, 매핑, 집계, 정렬, 그룹화 등 다양한 작업을 함수형 스타일로 수행할 수 있습니다.
스트림은 데이터를 처리하는 데 있어 선언적 접근 방식을 제공하며, 컬렉션의 요소를 하나씩 처리하는 반복적 코드를 작성할 필요 없이 데이터를 다룰 수 있게 해 줍니다.

 

Stream의 주요 특징

-선언적 프로그래밍: 스트림은 무엇을 할 것인지를 선언적으로 정의하고, 어떻게 할 것인지를 명시하지 않습니다. 코드가 더 간결하고 이해하기 쉬워집니다.

-병렬 처리: 스트림은 쉽게 병렬로 처리할 수 있습니다. 병렬 스트림을 사용하면 멀티코어 프로세서를 활용하여 성능을 높일 수 있습니다.

-중간 연산과 최종 연산: 스트림 연산은 중간 연산과 최종 연산으로 나뉩니다. 중간 연산은 스트림을 변환하지만 결과를 생성하지 않고, 최종 연산은 스트림을 소비하여 결과를 생성합니다.

-지연 연산: 최종 연산이 호출될 때까지 실제 연산이 수행되지 않습니다. 불필요한 연산을 줄이고 성능을 최적화하는 데 도움이 됩니다.

 

소스코드

• transformToUpperCase 메서드: 문자열 리스트의 각 요소를 대문자로 변환합니다.

private static void transformToUpperCase() {
    List<String> names = Arrays.asList("alice", "bob", "charlie");

    List<String> upperCaseNames = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());

    System.out.println("Upper case names: " + upperCaseNames);  // [ALICE, BOB, CHARLIE]
}

 

• filterEvenNumbers 메서드: 정수 리스트에서 짝수만 필터링합니다.

private static void filterEvenNumbers() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

    List<Integer> evenNumbers = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());

    System.out.println("Even numbers: " + evenNumbers);  // [2, 4, 6, 8, 10]
}

 

• calculateSum 메서드: 정수 리스트의 합계를 계산합니다.

private static void calculateSum() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

    int sum = numbers.stream()
            .mapToInt(Integer::intValue)
            .sum();

    System.out.println("Sum: " + sum);  // 15
}

 

• extractFieldValues 메서드: 객체 리스트에서 특정 필드 값을 추출합니다. 여기서는 Person 객체의 name 필드를 추출합니다.

private static void extractFieldValues() {
    List<Person> people = Arrays.asList(
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
    );

    List<String> names = people.stream()
            .map(Person::getName)
            .collect(Collectors.toList());

    System.out.println("Names: " + names);  // [Alice, Bob, Charlie]
}

 

• joinStrings 메서드: 문자열 리스트를 공백으로 결합합니다.

private static void joinStrings() {
    List<String> words = Arrays.asList("Hello", "world", "this", "is", "Java");

    String sentence = words.stream()
            .collect(Collectors.joining(" "));

    System.out.println("Sentence: " + sentence);  // Hello world this is Java
}

 

• sortNumbers 메서드:정수 리스트를 정렬합니다.

private static void sortNumbers() {
    List<Integer> numbers = Arrays.asList(5, 3, 8, 1, 9, 2);

    List<Integer> sortedNumbers = numbers.stream()
            .sorted()
            .collect(Collectors.toList());

    System.out.println("Sorted numbers: " + sortedNumbers);  // [1, 2, 3, 5, 8, 9]
}

 

• removeDuplicates 메서드: 리스트에서 중복 요소를 제거합니다.\

private static void removeDuplicates() {
    List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);

    List<Integer> uniqueNumbers = numbers.stream()
            .distinct()
            .collect(Collectors.toList());

    System.out.println("Unique numbers: " + uniqueNumbers);  // [1, 2, 3, 4, 5]
}

 

• countElements 메서드: 리스트의 요소 개수를 셉니다.

private static void countElements() {
    List<String> words = Arrays.asList("Hello", "world", "this", "is", "Java");

    long count = words.stream().count();

    System.out.println("Count of words: " + count);  // 5
}

 

• findFirstElement 메서드: 조건을 만족하는 첫 번째 요소를 찾습니다.

private static void findFirstElement() {
    List<String> words = Arrays.asList("apple", "banana", "cherry", "date");

    String first = words.stream()
            .filter(word -> word.startsWith("c"))
            .findFirst()
            .orElse("No match");

    System.out.println("First element starting with 'c': " + first);  // cherry
}

 

• groupByAge 메서드: 객체 리스트를 특정 필드로 그룹화합니다. 여기서는 Person 객체를 age 필드로 그룹화합니다.

private static void groupByAge() {
    List<Person> people = Arrays.asList(
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35),
            new Person("David", 30)
    );

    Map<Integer, List<Person>> groupedByAge = people.stream()
            .collect(Collectors.groupingBy(Person::getAge));

    System.out.println("Grouped by age: " + groupedByAge);
    // Grouped by age: {35=[Charlie (35)], 25=[Bob (25)], 30=[Alice (30), David (30)]}
}

 

 

전체코드

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class TEST {
    public static void main(String[] args) throws Exception {
        // 모든 문자열을 대문자로 변환
        transformToUpperCase();

        // 리스트에서 짝수만 필터링
        filterEvenNumbers();

        // 숫자 리스트의 합계 구하기
        calculateSum();

        // 객체 리스트에서 특정 필드 값 추출
        extractFieldValues();

        // 문자열 리스트를 공백으로 결합
        joinStrings();

        // 숫자 리스트를 정렬
        sortNumbers();

        // 리스트에서 중복 요소 제거
        removeDuplicates();

        // 리스트의 요소 개수 세기
        countElements();

        // 조건을 만족하는 첫 번째 요소 찾기
        findFirstElement();

        // 객체 리스트를 특정 필드로 그룹화
        groupByAge();
    }

    private static void transformToUpperCase() {
        List<String> names = Arrays.asList("alice", "bob", "charlie");

        List<String> upperCaseNames = names.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());

        System.out.println("Upper case names: " + upperCaseNames);  // [ALICE, BOB, CHARLIE]
    }

    private static void filterEvenNumbers() {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        List<Integer> evenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());

        System.out.println("Even numbers: " + evenNumbers);  // [2, 4, 6, 8, 10]
    }

    private static void calculateSum() {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        int sum = numbers.stream()
                .mapToInt(Integer::intValue)
                .sum();

        System.out.println("Sum: " + sum);  // 15
    }

    private static void extractFieldValues() {
        List<Person> people = Arrays.asList(
                new Person("Alice", 30),
                new Person("Bob", 25),
                new Person("Charlie", 35)
        );

        List<String> names = people.stream()
                .map(Person::getName)
                .collect(Collectors.toList());

        System.out.println("Names: " + names);  // [Alice, Bob, Charlie]
    }

    private static void joinStrings() {
        List<String> words = Arrays.asList("Hello", "world", "this", "is", "Java");

        String sentence = words.stream()
                .collect(Collectors.joining(" "));

        System.out.println("Sentence: " + sentence);  // Hello world this is Java
    }

    private static void sortNumbers() {
        List<Integer> numbers = Arrays.asList(5, 3, 8, 1, 9, 2);

        List<Integer> sortedNumbers = numbers.stream()
                .sorted()
                .collect(Collectors.toList());

        System.out.println("Sorted numbers: " + sortedNumbers);  // [1, 2, 3, 5, 8, 9]
    }

    private static void removeDuplicates() {
        List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);

        List<Integer> uniqueNumbers = numbers.stream()
                .distinct()
                .collect(Collectors.toList());

        System.out.println("Unique numbers: " + uniqueNumbers);  // [1, 2, 3, 4, 5]
    }

    private static void countElements() {
        List<String> words = Arrays.asList("Hello", "world", "this", "is", "Java");

        long count = words.stream().count();

        System.out.println("Count of words: " + count);  // 5
    }

    private static void findFirstElement() {
        List<String> words = Arrays.asList("apple", "banana", "cherry", "date");

        String first = words.stream()
                .filter(word -> word.startsWith("c"))
                .findFirst()
                .orElse("No match");

        System.out.println("First element starting with 'c': " + first);  // cherry
    }

    private static void groupByAge() {
        List<Person> people = Arrays.asList(
                new Person("Alice", 30),
                new Person("Bob", 25),
                new Person("Charlie", 35),
                new Person("David", 30)
        );

        Map<Integer, List<Person>> groupedByAge = people.stream()
                .collect(Collectors.groupingBy(Person::getAge));

        System.out.println("Grouped by age: " + groupedByAge);
        // Grouped by age: {35=[Charlie (35)], 25=[Bob (25)], 30=[Alice (30), David (30)]}
    }
}
class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

 

---

console.log