java 스트림 사용법 및 예제(중간 연산)

Java Stream: 필터 작업 이해

Java 스트림의 `filter` 작업은 주어진 조건에 따라 스트림에서 요소를 선택적으로 포함하거나 제외할 수 있는 강력한 도구입니다. 

'Predicate'를 인수로 사용하는 중간 작업이며, 조건자를 만족하는 요소는 결과 스트림에 유지됩니다.

`필터` 작업을 사용하는 방법

`filter` 작업을 사용하는 구문은 간단합니다.

데이터 소스(예: 컬렉션 또는 배열)에서 스트림을 생성한 후 `filter` 메서드를 연결하여 스트림의 각 요소에 조건을 적용할 수 있습니다.

Stream<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).stream();

// Using filter to retain only even numbers
Stream<Integer> evenNumbers = numbers.filter(n -> n % 2 == 0);

이 예에서 `filter` 작업은 람다 식을 조건자로 사용합니다.

람다 표현식은 숫자가 짝수인지(`n % 2 == 0`) 확인합니다.

이 조건을 만족하는 요소만 'evenNumbers' 스트림에 포함됩니다.

예: 길이를 기준으로 문자열 필터링

길이를 기준으로 문자열 목록을 필터링하는 실제 예를 고려해 보겠습니다. 길이가 5보다 큰 문자열만 포함하려고 합니다.

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

public class StreamFilterExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "orange", "grape", "kiwi", "pear", "melon");

        // Using filter to include only strings with length greater than 5
        List<String> longWords = words.stream()
                                      .filter(s -> s.length() > 5)
                                      .collect(Collectors.toList());

        System.out.println("Original List: " + words);
        System.out.println("Filtered List: " + longWords);
    }
}

이 예에서는 '필터' 작업이 단어 스트림에 적용됩니다. 람다 표현식은 각 문자열(`s.length()`)의 길이가 5보다 큰지 확인합니다. 결과 `longWords` 목록에는 이 기준을 충족하는 문자열만 포함됩니다.

 

결론

Java 스트림의 `filter` 작업은 지정된 조건에 따라 요소를 선택적으로 처리하기 위한 강력하고 유연한 도구입니다.

간결하고 표현력이 풍부한 코드를 장려하므로 개발자는 수동 반복보다는 포함 또는 제외 기준에 집중할 수 있습니다.

이는 Java에서 컬렉션으로 작업할 때 코드를 더 읽기 쉽고 유지 관리하기 쉽게 만드는 데 도움이 됩니다.

 

 

 

Java Stream: 맵 작업 이해

Java 스트림에서 `map` 작업은 주어진 함수를 사용하여 스트림의 각 요소를 변환하는 강력한 도구입니다. 

이는 '함수'를 인수로 사용하고 이를 스트림의 각 요소에 적용하여 변환된 요소의 새 스트림을 생성하는 중간 작업입니다.

`map` 작업을 사용하는 방법

`map` 작업을 사용하는 구문은 간단합니다. 

데이터 소스(예: 컬렉션 또는 배열)에서 스트림을 생성한 후 'map' 메서드를 연결하여 스트림의 각 요소에 함수를 적용할 수 있습니다.

Stream<String> words = Arrays.asList("apple", "banana", "orange", "grape").stream();

// Using map to transform each string to uppercase
Stream<String> uppercasedWords = words.map(String::toUpperCase);

이 예에서 `map` 작업은 메서드 참조(`String::toUpperCase`)를 함수로 사용합니다. 이 함수는 `words` 스트림의 각 요소에 적용되어 문자열의 대문자 버전을 포함하는 새로운 스트림 `uppercasedWords`가 생성됩니다.

 

예: 정수를 해당 제곱에 매핑

`map` 연산을 사용하여 정수 목록을 해당 제곱에 매핑하는 실제 예를 고려해 보겠습니다.

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

public class StreamMapExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Using map to transform each number to its square
        List<Integer> squares = numbers.stream()
                                          .map(n -> n * n)
                                          .collect(Collectors.toList());

        System.out.println("Original List: " + numbers);
        System.out.println("Squared List: " + squares);
    }
}

이 예에서는 `map` 연산이 숫자 스트림에 적용됩니다. 

람다 표현식(`n -> n * n`)은 스트림의 각 요소를 제곱하는 함수입니다. 

결과 `제곱` 목록에는 원래 숫자의 제곱 값이 포함됩니다.

결론

Java 스트림의 `map` 작업은 지정된 기능을 기반으로 요소를 변환하는 다양하고 유용한 도구입니다. 

이를 통해 개발자는 명시적인 반복 없이 각 요소에 대한 작업을 수행할 수 있으므로 더 간결하고 표현력이 풍부한 코드가 생성됩니다. 

`map` 작업을 이해하고 활용하면 Java에서 컬렉션을 사용할 때 더욱 깔끔하고 기능적인 코드를 작성하는 데 도움이 됩니다.

 

 

 

Java Stream: flatMap 작업 이해

Java 스트림에서 ` flatMap` 작업은 스트림의 각 요소를 변환할 뿐만 아니라 중첩된 스트림을 단일 스트림으로 병합하여 결과를 평면화하는 강력한 도구입니다. 

이는 '함수'를 인수로 사용하고 이를 스트림의 각 요소에 적용하여 변환된 요소의 새 스트림을 생성하는 중간 작업입니다.

flatMap 작업을 사용하는 방법

` flatMap` 작업을 사용하는 구문은 `map` 작업과 유사합니다. 

데이터 소스(예: 컬렉션 또는 배열)에서 스트림을 생성한 후 `platMap` 메서드를 연결하여 스트림의 각 요소에 함수를 적용할 수 있습니다. 

그러나 함수는 스트림을 반환해야 하며 결과 스트림은 단일 스트림으로 평면화됩니다.

List<List<String>> nestedWords = Arrays.asList(
    Arrays.asList("apple", "banana", "cherry"),
    Arrays.asList("date", "elderberry", "fig"),
    Arrays.asList("grape", "honeydew", "kiwi")
);

// Using flatMap to flatten nested lists of strings into a single stream
List<String> flattenedWords = nestedWords.stream()
                                           .flatMap(List::stream)
                                           .collect(Collectors.toList());

이 예에서 ` flatMap` 작업은 메서드 참조(`List::stream`)를 함수로 사용합니다. 

이 함수는 `nestedWords` 스트림의 각 중첩 목록에 적용되어 중첩 목록의 모든 문자열을 포함하는 새 스트림이 생성된 다음 단일 목록으로 수집됩니다.

 

예: 목록 평면화

정수 목록 목록이 있고 이를 단일 목록으로 평면화하려는 실제 예를 고려해 보겠습니다.

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

public class StreamFlatMapExample {
    public static void main(String[] args) {
        List<List<Integer>> nestedNumbers = Arrays.asList(
            Arrays.asList(1, 2, 3),
            Arrays.asList(4, 5, 6),
            Arrays.asList(7, 8, 9)
        );

        // Using flatMap to flatten nested lists of integers into a single stream
        List<Integer> flattenedNumbers = nestedNumbers.stream()
                                                         .flatMap(List::stream)
                                                         .collect(Collectors.toList());

        System.out.println("Original Nested Lists: " + nestedNumbers);
        System.out.println("Flattened List: " + flattenedNumbers);
    }
}

이 예에서는 '플랫맵' 작업이 중첩된 정수 목록 스트림에 적용됩니다. 

결과 ` flattenedNumbers ` 목록에는 중첩 목록의 모든 정수가 포함되며 ` flatMap`의 평면화 효과를 보여주기 위해 인쇄됩니다.

 

결론

Java 스트림의 '플랫맵' 작업은 중첩된 구조를 처리하는 강력한 도구입니다. 

요소를 변환할 뿐만 아니라 중첩된 스트림을 단일 스트림으로 효율적으로 평면화하여 복잡한 데이터 구조의 처리를 단순화합니다. 

` flatMap`을 이해하고 사용하면 Java에서 컬렉션으로 작업할 때 더욱 간결하고 표현력이 풍부한 코드를 작성하는 데 도움이 됩니다.

 

 

 

Java Stream: Understanding the distinct Operation

Java 스트림에서 `distinct` 작업은 스트림에서 중복 요소를 제거하는 편리한 방법입니다.

이는 자연 순서 또는 제공된 비교기를 기반으로 개별 요소로 구성된 스트림을 반환하는 중간 작업입니다.

How to Use the `distinct` Operation

`distinct` 연산을 사용하는 구문은 간단합니다. 

데이터 소스(예: 컬렉션 또는 배열)에서 스트림을 생성한 후 `distinct` 메서드를 연결하여 고유한 요소가 있는 스트림을 얻을 수 있습니다.

List<String> fruits = Arrays.asList("apple", "banana", "orange", "apple", "kiwi", "banana");

// Using distinct to obtain a stream with unique elements
List<String> uniqueFruits = fruits.stream()
                                   .distinct()
                                   .collect(Collectors.toList());

이 예에서는 'distinct' 연산이 과일 흐름에 적용됩니다. 

결과 `uniqueFruits` 목록에는 고유한 요소만 포함되며 원본 목록에서 중복된 요소는 모두 제거됩니다.

 

예: 정수 목록의 고유 요소

정수 목록이 있고 고유한 요소가 있는 스트림을 얻으려는 실제 예를 고려해 보겠습니다.:

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

public class StreamDistinctExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 4, 5, 3, 6);

        // Using distinct to obtain a stream with distinct integers
        List<Integer> distinctNumbers = numbers.stream()
                                                   .distinct()
                                                   .collect(Collectors.toList());

        System.out.println("Original List: " + numbers);
        System.out.println("Distinct List: " + distinctNumbers);
    }
}

이 예에서는 `distinct` 연산이 숫자 스트림에 적용됩니다. 

결과 `distinctNumbers` 목록에는 고유한 정수만 포함되며 원본 목록에서 중복된 항목은 모두 제거됩니다.

 

결론

Java 스트림의 `distinct` 연산은 고유한 요소가 있는 스트림을 얻는 데 유용한 도구입니다. 

컬렉션에서 중복 항목을 제거하는 간결하고 효율적인 방법을 제공하므로 대규모 데이터 세트나 반복되는 요소가 있는 목록으로 작업할 때 특히 유용합니다. 

'distinct'를 이해하고 사용하면 Java에서 컬렉션을 처리할 때 더 깔끔하고 효율적인 코드를 작성하는 데 도움이 됩니다.

 

 

 

Java Stream: Understanding the sorted Operation

Java 스트림에서 '정렬' 작업을 사용하면 자연 순서 또는 제공된 비교기에 따라 정렬된 요소가 있는 스트림을 얻을 수 있습니다. 

정렬된 요소가 포함된 새 스트림을 반환하는 중간 작업입니다.

How to Use the `sorted` Operation

'정렬' 작업을 사용하는 구문은 간단합니다. 

데이터 소스(예: 컬렉션 또는 배열)에서 스트림을 생성한 후 `sorted` 메서드를 연결하여 정렬된 순서로 요소가 포함된 스트림을 얻을 수 있습니다.

List<String> fruits = Arrays.asList("orange", "apple", "kiwi", "banana");

// Using sorted to obtain a stream with elements sorted in natural order
List<String> sortedFruits = fruits.stream()
                                   .sorted()
                                   .collect(Collectors.toList());

이 예에서는 '정렬' 작업이 과일 스트림에 적용됩니다. 

결과 `sortedFruits` 목록에는 자연 순서(문자열의 경우 알파벳 순서)로 정렬된 요소가 포함됩니다.

.

예: 내림차순으로 정수 정렬

정수 목록이 있고 요소가 내림차순으로 정렬된 스트림을 얻으려는 실제 예를 고려해 보겠습니다.

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

public class StreamSortedExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 6, 3, 7);

        // Using sorted to obtain a stream with integers sorted in descending order
        List<Integer> descendingNumbers = numbers.stream()
                                                     .sorted((a, b) -> b.compareTo(a))
                                                     .collect(Collectors.toList());

        System.out.println("Original List: " + numbers);
        System.out.println("Descending Order List: " + descendingNumbers);
    }
}

이 예에서는 `정렬` 작업이 숫자 스트림에 적용됩니다. 

비교기(`(a, b) -> b.compareTo(a)`)는 정수를 내림차순으로 정렬하는 데 사용됩니다. 

결과 `descendingNumbers` 목록에는 가장 높은 것부터 가장 낮은 것 순으로 정렬된 정수가 포함됩니다.

 

결론

Java 스트림의 `정렬` 작업은 원하는 순서의 요소가 포함된 스트림을 얻는 데 유용한 도구입니다. 

자연 순서에 따라 정렬하든 사용자 정의 비교기를 제공하든 요소 정렬에 유연성을 제공합니다. 

'sorted'를 이해하고 사용하면 Java에서 컬렉션을 처리할 때 더 다양하고 읽기 쉬운 코드를 작성하는 데 도움이 됩니다.

 

 

 

Java Stream: Understanding the peek Operation

Java 스트림에서 `peek` 작업은 요소를 수정하지 않고 스트림의 각 요소에 대해 지정된 작업을 수행할 수 있는 비터미널 작업입니다. 

이는 요소가 스트림 파이프라인을 통과할 때 요소를 관찰하기 위해 디버깅 또는 로깅 목적으로 자주 사용됩니다.

How to Use the `peek` Operation

`peek` 작업을 사용하는 구문은 간단합니다. 

데이터 소스(예: 컬렉션 또는 배열)에서 스트림을 생성한 후 `peek` 메서드를 연결하여 각 요소에 대한 작업을 수행할 수 있습니다.

List<String> fruits = Arrays.asList("apple", "banana", "orange", "kiwi");

// Using peek to print each element in the stream
fruits.stream()
      .peek(System.out::println)
      .collect(Collectors.toList());

이 예에서는 'peek' 작업이 과일 흐름에 적용됩니다. 

`System.out::println` 메서드 참조는 스트림의 각 요소를 인쇄하는 데 사용되므로 요소가 스트림 파이프라인을 통과할 때 요소를 관찰할 수 있습니다.

 

예: 요소 수정 및 관찰

숫자 목록이 있고 `peek`를 사용하여 각 숫자를 두 배로 늘리고 중간 및 최종 결과를 인쇄하려는 실제 예를 고려해 보겠습니다.

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

public class StreamPeekExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Using peek to double each number and print intermediate and final results
        List<Integer> doubledNumbers = numbers.stream()
                                                  .peek(n -> System.out.println("Original: " + n))
                                                  .map(n -> n * 2)
                                                  .peek(n -> System.out.println("Doubled: " + n))
                                                  .collect(Collectors.toList());
    }
}

이 예에서는 'map' 작업 전후에 'peek' 작업이 적용됩니다. 

첫 번째 'peek'는 각 원래 숫자를 인쇄하는 데 사용되며 두 번째 'peek'는 각 두 배의 숫자를 인쇄합니다. 

이를 통해 스트림 파이프라인의 여러 단계에서 요소를 관찰할 수 있습니다.

 

결론

Java 스트림의 `peek` 작업은 디버깅 및 로깅 목적을 위한 편리한 도구입니다. 

이는 스트림의 요소를 변경하지 않고 관찰할 수 있는 방법을 제공하므로 개발 중에 스트림 파이프라인에 대한 통찰력을 얻는 데 유용합니다. 

'peek'을 이해하고 사용하면 디버깅 프로세스가 향상되고 Java에서 스트림 처리 코드의 명확성이 향상될 수 있습니다.

 

 

 

Java Stream: Understanding the limit Operation

Java 스트림에서 `limit` 작업은 스트림을 잘라 처리하는 요소 수를 제한할 수 있는 편리한 도구입니다. 

이는 단락 작업입니다. 즉, 지정된 한도에 도달하면 요소 처리가 중지됩니다.

How to Use the `limit` Operation

`limit` 연산을 사용하는 구문은 간단합니다. 

데이터 소스(예: 컬렉션 또는 배열)에서 스트림을 생성한 후 `limit` 메서드를 연결하여 요소 수를 제한할 수 있습니다.

List<String> fruits = Arrays.asList("apple", "banana", "orange", "kiwi");

// Using limit to process only the first two elements in the stream
List<String> limitedFruits = fruits.stream()
                                      .limit(2)
                                      .collect(Collectors.toList());

이 예에서는 'limit' 작업이 과일 스트림에 적용되어 처음 두 요소만 처리되도록 지정합니다. 

결과 `limitedFruits` 목록에는 해당 두 요소만 포함됩니다.

 

예: 제한된 수의 정수 처리

정수 목록이 있고 `limit`를 사용하여 처음 세 숫자만 처리하려는 실제 예를 고려해 보겠습니다.

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

public class StreamLimitExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

        // Using limit to process only the first three numbers
        List<Integer> limitedNumbers = numbers.stream()
                                                .limit(3)
                                                .collect(Collectors.toList());

        System.out.println("Original List: " + numbers);
        System.out.println("Limited List: " + limitedNumbers);
    }
}

이 예에서는 'limit' 연산이 숫자 스트림에 적용되어 처음 세 숫자만 처리되도록 지정합니다. 

결과 `limitedNumbers` 목록에는 이러한 세 가지 요소가 포함됩니다.

 

결론

Java 스트림의 '제한' 작업은 특히 대규모 데이터 세트를 처리할 때 스트림 크기를 제어하는 데 유용한 도구입니다. 

이는 특정 수의 요소를 처리하는 간단하고 효과적인 방법을 제공하여 보다 효율적인 스트림 처리에 기여합니다. 

'limit'를 이해하고 사용하면 Java에서 스트림 작업의 유연성이 향상됩니다.