Java8 Stream 상세 설명 및 종료 연산 방법 사용 예(3)

종료 작업은 Stream의 처리를 종료하고 Stream의 실행을 트리거하는 작업을 의미합니다. 다음은 일반적으로 사용되는 종료 작업 방법입니다. 종료 작업은 데이터 소스를 순회하므로 조기에 평가됩니다.

Java8 Stream에 대한 자세한 설명 및 중간 연산 방법 사용 예(1)
Java8 Stream에 대한 자세한 설명 및 스트림 생성 방법 사용 예(2)

forEach(Consumer<T> action): 스트림의 각 요소에 대해 지정된 작업을 수행합니다.

toArray(): 스트림의 요소를 배열로 변환합니다.

Reduce(Tidentity, BinaryOperator<T> accumulator): 지정된 누산기를 사용하여 스트림의 요소를 집계합니다.

Collect(Collector<T,A,R> Collector): 스트림의 요소를 컨테이너로 수집합니다.

min(Comparator<T> comparator): 스트림에서 가장 작은 요소를 반환합니다.

max(Comparator<T> comparator): 스트림에서 가장 큰 요소를 반환합니다.

count(): 스트림의 요소 수를 반환합니다.

anyMatch(Predicate<T> predicate): 스트림의 요소가 지정된 조건과 일치하는지 확인합니다.

allMatch(Predicate<T> predicate): 스트림의 모든 요소가 지정된 조건과 일치하는지 확인합니다.

noneMatch(Predicate<T> predicate): 스트림의 요소가 지정된 조건과 일치하는지 확인합니다.

findFirst(): 스트림의 첫 번째 요소를 반환합니다.

findAny(): 스트림의 모든 요소를 반환합니다.

스트림 종료 작업 방법 세부 예

forEach(소비자<? super T> 작업)

forEach()method는 스트림의 각 요소에 지정된 작업을 수행하기 위해 함수를 인수로 Stream받는 클래스의 최종 작업 메서드 입니다. 메소드는 스트림 전체를 순회하면서 각 요소에 대해 지정된 연산을 수행하며, 연산 순서는 스트림의 순서대로 수행된다.ConsumerforEach()

예를 들어, 여러 문자열을 포함하는 목록이 있고 이제 각 문자열을 소문자로 변환하여 출력해야 한다고 가정하면 이 forEach()메서드를 사용하여 다음을 수행할 수 있습니다.
List<String> strList = Arrays.asList("Java", "Stream", "API");
strList.stream()
       .map(String::toLowerCase)
       .forEach(System.out::println);
위 코드에서는 먼저 문자열 목록에서 하나를 만든 Stream다음 String::toLowerCase각 문자열에 대해 메서드를 실행합니다. 즉, 문자열을 소문자로 변환하고 마지막으로 forEach()메서드를 통해 각 요소에 대한 작업을 실행합니다 System.out::println. 즉, 요소를 다음으로 출력합니다. 콘솔.

forEach()이 메서드는 최종 작업 메서드 이므로 어떤 값도 반환할 수 없습니다. 스트림의 요소를 컬렉션이나 배열과 같은 다른 개체로 변환해야 하는 경우 collect()메서드를 사용할 수 있습니다. 동시에, forEach()이 방법은 터미널 작업이기 때문에 동일한 스트림에 대한 연속적인 작업을 더 이상 수행할 수 없으며, 작업을 위해서는 새로운 스트림을 다시 생성해야 합니다.

또한 forEach()이 방법은 차단 작업이므로 많은 양의 데이터를 처리할 때 성능 문제가 발생할 수 있습니다. 처리 효율성을 위해 작업을 병렬로 수행해야 하는 경우 forEachOrdered()해당 방법 또는 parallelStream()방법을 사용할 수 있습니다. forEachOrdered()이 방법 forEach()은 방법과 유사하지만 요소가 원래 순서대로 처리된다는 점을 보장하며, parallelStream()이 방법은 스트림을 병렬 스트림으로 변환하여 멀티 코어 프로세서에서 병렬 작업을 수행할 수 있습니다.

forEachOrdered(소비자<? super T> 작업)

forEachOrdered()메서드는 Stream클래스의 최종 작업 메서드로, 메서드 와 유사하게 Consumer스트림의 각 요소에 대해 지정된 작업을 수행하는 데 사용되는 함수를 매개 변수로 받습니다. forEach()차이점은 forEachOrdered()메서드가 스트림에 있는 요소의 원래 순서대로 작업을 순차적으로 실행하도록 보장된다는 것입니다.

예를 들어 여러 문자열을 포함하는 목록이 있고 이제 각 문자열을 소문자로 변환하여 출력해야 한다고 가정합니다. 출력 순서는 다음 메서드를 사용하여 얻을 수 있는 원래 순서와 일치해야 합니다 forEachOrdered().
List<String> strList = Arrays.asList("Java", "Stream", "API");
strList.stream()
       .map(String::toLowerCase)
       .forEachOrdered(System.out::println);
위 코드에서는 먼저 문자열 목록에서 하나를 만든 Stream다음 String::toLowerCase각 문자열에 대해 메서드를 실행합니다. 즉, 문자열을 소문자로 변환하고 마지막으로 forEachOrdered()메서드를 통해 각 요소에 대한 작업을 실행합니다 System.out::println. 즉, 요소를 다음으로 출력합니다. 콘솔. 메서드가 호출되었으므로 forEachOrdered()출력 순서는 원래 순서와 동일하게 유지됩니다.

forEachOrdered()이 메서드는 최종 작업 메서드 이므로 어떤 값도 반환할 수 없습니다. 스트림의 요소를 컬렉션이나 배열과 같은 다른 개체로 변환해야 하는 경우 collect()메서드를 사용할 수 있습니다. 또한 forEachOrdered()해당 방식은 블로킹 연산이기 때문에 대용량 데이터를 처리할 경우 성능 문제가 발생할 수 있다. 처리 효율성을 위해 작업을 병렬로 실행해야 하는 경우 parallelStream()이 방법을 사용할 수 있습니다.

toArray()

toArray() 메서드는 Stream 개체의 요소를 배열로 변환하고 반환하는 종료 작업입니다. 이 메서드는 매개변수를 받지 않으며 일반 유형 추론을 사용하여 캐스팅할 수 있는 객체 유형의 배열을 반환합니다.

구체적인 사용법은 다음과 같습니다.

여러 요소를 포함하는 Stream 개체를 만듭니다.

toArray() 메서드를 호출합니다.

이 메서드는 Stream 개체의 요소를 개체 유형의 배열로 변환하고 해당 배열을 반환합니다.

예를 들어, 다음 코드는 toArray() 메서드를 사용하여 문자열 스트림의 요소를 배열로 변환하는 방법을 보여줍니다.
List<String> list = Arrays.asList("apple", "banana", "orange", "pear");
Object[] array = list.stream().toArray();
System.out.println(Arrays.toString(array)); // 输出 [apple, banana, orange, pear]
위의 코드는 String 유형 목록을 생성하고 이를 Stream 개체로 변환합니다. 다음으로 Stream 객체의 요소를 Object 유형의 배열로 변환하고 해당 배열을 반환하는 toArray() 메서드가 호출됩니다. 마지막으로 Arrays.toString() 메서드를 사용하여 배열을 문자열로 변환하고 콘솔에 출력합니다.

toArray() 메서드는 Object 유형의 배열을 반환하므로 강제 유형 변환을 위해서는 일반 유형 추론을 사용해야 합니다. 예를 들어, String 유형의 요소를 String 유형의 배열로 변환하려는 경우 다음 코드를 사용할 수 있습니다.
String[] strArray = list.stream().toArray(String[]::new);
여기서는 메소드 참조 형식을 사용하고 생성자 String[]::new를 toArray() 메소드에 매개변수로 전달하여 Object 유형의 배열을 String 유형의 배열로 변환합니다.

toArray(IntFunction<A[]> 생성기)

toArray(IntFunction<A[]> 생성기) 메서드는 Stream 개체의 요소를 지정된 유형의 새 배열로 변환하고 반환하는 데 사용되는 종료 작업입니다. 이 메서드는 Stream 개체의 모든 요소를 수용하기 위해 지정된 크기의 새 배열을 만드는 데 사용되는 IntFunction 함수를 매개 변수로 받습니다.

구체적인 사용법은 다음과 같습니다.

여러 요소를 포함하는 Stream 개체를 만듭니다.

toArray(IntFunction<A[]> 생성기) 메서드를 호출하고 IntFunction 함수를 전달합니다.

이 메서드는 IntFunction 함수를 사용하여 지정된 크기의 새 배열을 만들고 Stream 개체의 요소를 배열로 변환합니다.

예를 들어, 다음 코드는 toArray() 메서드와 Lambda 표현식을 사용하여 문자열 스트림의 요소를 String 유형의 배열로 변환하는 방법을 보여줍니다.
List<String> list = Arrays.asList("apple", "banana", "orange", "pear");
String[] strArray = list.stream().toArray(size -> new String[size]);
System.out.println(Arrays.toString(strArray)); // 输出 [apple, banana, orange, pear]
위의 코드는 String 유형 목록을 생성하고 이를 Stream 개체로 변환합니다. 다음으로 toArray() 메서드를 호출하고 주어진 크기에 따라 String 유형의 배열을 생성하는 Lambda 표현식을 전달합니다. 이 메서드는 Lambda 표현식을 사용하여 새 배열을 생성하고 Stream 개체의 요소를 배열로 변환합니다. 마지막으로 Arrays.toString() 메서드를 사용하여 배열을 문자열로 변환하고 콘솔에 출력합니다.

지정된 유형의 배열을 생성해야 하므로 제네릭을 사용하고 유형 변환을 수행해야 한다는 점에 유의해야 합니다. 위의 예에서는 Lambda 표현식(size -> new String[size])을 사용하여 String 유형의 새 배열을 생성했습니다. 크기 값에 따라 이 표현식은 지정된 크기의 문자열 유형 배열을 반환합니다.

감소(BinaryOperator<T> 누산기)

Reduce(BinaryOperator<T> accumulator) 메서드는 모든 요소를 단일 결과로 줄이는 종료 작업입니다. 이 메서드는 스트림의 요소에 대해 누적 작업을 수행하는 데 사용되는 BinaryOperator 함수를 매개 변수로 받습니다.

구체적인 사용법은 다음과 같습니다.

여러 요소를 포함하는 Stream 개체를 만듭니다.

Reduce(BinaryOperator<T> accumulator) 메서드를 호출하고 BinaryOperator 함수를 전달합니다.

이 메소드는 전체 스트림에 대해 지정된 누적 작업을 수행하고 결과가 포함된 Optional 개체를 반환합니다.

예를 들어, 다음 코드는 Reduce() 메서드를 사용하여 정수 목록에 있는 모든 요소의 합계를 계산하는 방법을 보여줍니다.
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> result = list.stream().reduce((a, b) -> a + b);
result.ifPresent(System.out::println); // 输出15
위의 코드는 Integer 유형의 목록을 생성하고 이를 Stream 개체로 변환합니다. 다음으로, 각 요소에 대해 누적 작업을 수행하고 결과가 포함된 Optional 개체를 반환하는 Reduce() 메서드를 호출합니다. 마지막으로, ifPresent() 메소드를 사용하여 결과를 인쇄합니다. 왜냐하면 Reduce() 메소드는 널 포인터 예외를 방지하기 위해 Optional 객체를 반환하기 때문입니다.

위의 시작값이 없는 버전 축소(BinaryOperator<T> 누산기) 외에도 시작값이 포함된 버전 감소(T ID, BinaryOperator<T> 누산기)도 있습니다. 이 메서드의 첫 번째 매개변수 ID는 초기값을 나타냅니다. 값.널 포인터 예외를 피할 수 있으며 시작 부분의 결과는 초기 값입니다. 예를 들어, 다음 코드는 시작 값과 함께 Reduce() 메서드를 사용하여 정수 목록에 있는 모든 요소의 합계를 계산하는 방법을 보여줍니다.
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int result = list.stream().reduce(0, (a, b) -> a + b);
System.out.println(result); // 输出15
위의 코드는 Integer 유형의 목록을 생성하고 이를 Stream 객체로 변환합니다. 다음으로, Reduce() 메서드를 호출하고, 초기값 0을 지정하고, 각 요소에 대해 누적 연산을 수행하고 최종 결과를 반환합니다. Reduce() 메서드가 기본 데이터 유형을 반환하기 때문에 결과는 마지막에 인쇄됩니다.

Reduce(U 항등식, BiFunction<U,? super T,U> 누산기, BinaryOperator<U> 결합기)

Reduce(U ID, BiFunction<U,? super T, U> 누산기, BinaryOperator<U> 결합기) 메서드는 모든 요소를 단일 결과로 줄이는 종료 작업입니다. 이 메소드는 세 개의 매개변수를 받습니다. 첫 번째 매개변수는 초기 값 항등이고, 두 번째 매개변수는 각 요소를 특정 유형 U로 변환하고 이전 부분 결과로 누적 연산을 수행하는 데 사용되는 BiFunction 함수이며, 세 번째 매개변수는 매개변수는 모든 부분 결과를 결합하여 최종 결과를 얻는 데 사용되는 BinaryOperator 함수입니다.

구체적인 사용법은 다음과 같습니다.

여러 요소를 포함하는 Stream 개체를 만듭니다.

Reduce(U ID, BiFunction<U,? super T, U> 누산기, BinaryOperator<U> 결합기) 메서드를 호출하고 초기 값, BiFunction 함수 및 BinaryOperator 함수를 전달합니다.

이 메소드는 전체 스트림에 대해 지정된 누적 작업을 수행하고 결과를 반환합니다.

예를 들어, 다음 코드는 문자열 목록에 있는 모든 요소의 길이 합계를 계산하기 위해 Reduce() 메서드를 사용하는 방법을 보여줍니다.
List<String> list = Arrays.asList("java", "python", "ruby");
int result = list.stream().reduce(0, (sum, str) -> sum + str.length(), Integer::sum);
System.out.println(result); // 输出14
위의 코드는 String 유형 목록을 생성하고 이를 Stream 개체로 변환합니다. 그런 다음, Reduce() 메서드를 호출하고 초기 값 0을 지정하고 각 요소의 길이를 초기 값에 추가한 다음 Integer::sum 메서드를 사용하여 모든 부분 결과를 결합합니다. 마지막으로 결과를 인쇄합니다. Reduce() 메서드는 기본 데이터 유형을 반환하므로 결과가 존재하는지 확인하기 위해 isPresent() 메서드를 사용할 필요가 없습니다.

주의할 점은 이 방법은 병렬적으로 동작할 수 있기 때문에 BiFunction 함수를 이용하여 각 부분 결과를 누적하고, BinaryOperator 함수를 이용하여 최종 결과를 결합해야 한다는 점에 유의해야 한다. 스트림에 여러 개의 부분 결과가 있는 경우 BinaryOperator 함수가 호출되어 이를 하나의 결과로 결합합니다.

Collect(수집기<? 슈퍼 T,A,R> 수집기)

collect(Collector<? super T,A,R> collector)Stream메소드는 스트림의 요소를 컨테이너 객체로 수집하기 위해 Java 8의 인터페이스에서 제공되는 메소드입니다 . Collector이 메서드 는 스트림의 요소를 수집하고 결과를 컨테이너 개체에 넣는 방법을 정의하는 매개 변수로 개체를 받습니다 .

다음은 사용 예입니다.
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamCollectExample {
    public static void main(String[] args) {
        List<String> names = Stream.of("Tom", "Jerry", "Mickey", "Minnie")
                .filter(name -> name.startsWith("M"))
                .collect(Collectors.toList());
        System.out.println(names); // [Mickey, Minnie]

        List<Integer> numbers = Stream.iterate(1, n -> n + 1)
                .limit(10)
                .collect(Collectors.toCollection(ArrayList::new));
        System.out.println(numbers); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        int sum = Stream.of(1, 2, 3, 4, 5)
                .collect(Collectors.summingInt(Integer::intValue));
        System.out.println(sum); // 15

        String joined = Stream.of("Hello", "world")
                .collect(Collectors.joining(", "));
        System.out.println(joined); // "Hello, world"
    }
}
위의 코드는 collect(). 첫 번째 예에서는 Collectors.toList()문자 "M"으로 시작하는 스트림의 문자열을 List개체로 수집하는 데 사용합니다. 두 번째 예에서는 를 사용하여 Collectors.toCollection(ArrayList::new)스트림의 처음 10개 정수를 ArrayList객체로 수집합니다. 세 번째 예에서는 Collectors.summingInt(Integer::intValue)스트림에 있는 정수의 합계를 계산합니다. 네 번째 예에서는 Collectors.joining(", ")스트림의 문자열을 하나의 문자열로 연결하는 데 사용합니다.

collect()메소드를 사용할 때 Collector스트림 요소를 수집하는 방법을 정의하는 객체 정의에 주의해야 합니다. 일반적으로 사용되는 구현 Collector클래스는 toList(), , 등이며 특정 요구 toSet()에 따라 선택할 수 있습니다.toMap()summingInt()joining()

Collect(Supplier<R> 공급자, BiConsumer<R,? super T> 누산기, BiConsumer<R,R> 결합기)

collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner)Stream메소드는 스트림의 요소를 컨테이너 객체로 수집하기 위해 Java 8의 인터페이스에서 제공되는 메소드입니다 . 이 메소드는 세 가지 매개변수를 받습니다:

supplier: 컨테이너 개체에 대한 팩토리 메서드를 제공합니다.

accumulator: 스트림의 요소를 수집하는 누산기 함수입니다.

combiner: 두 개의 컨테이너 객체를 하나로 병합하는 기능입니다.

다음은 사용 예입니다.
import java.util.ArrayList;
import java.util.List;

public class StreamCollectExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Tom");
        list.add("Jerry");
        list.add("Mickey");
        list.add("Minnie");

        List<String> result = list.stream().collect(
                ArrayList::new,
                (l, s) -> {
                    if (s.startsWith("M")) {
                        l.add(s);
                    }
                },
                List::addAll);

        System.out.println(result); // [Mickey, Minnie]
    }
}
위의 코드는 collect()메소드를 사용한 사용자 정의 컬렉션의 예를 보여줍니다. 먼저 컨테이너 개체로 개체가 생성되고 ArrayList개체에 일부 문자열이 추가됩니다. 그런 다음 stream()메서드를 통해 스트림을 가져오고 collect()메서드를 통해 사용자 지정 컬렉션을 수행합니다.

이 컬렉션 중에 컨테이너 개체를 생성하기 위한 팩토리 메서드를 ArrayList::new제공하는 데 사용 하고 문자 "M"으로 시작하는 문자열만 컨테이너 개체에 추가하는 누산기 함수를 정의하는 데 사용하고 병합 컨테이너 개체를 정의하는 데 사용합니다. 여러 컨테이너 개체의 요소를 하나로 통합합니다. 궁극적으로 문자 "M"으로 시작하는 문자열이 포함된 목록을 얻게 됩니다.ArrayList(l, s) -> {...}List::addAll

collect()이 방법을 사용할 때 특정 요구에 따라 다양한 수집 방법을 선택해야 하며 의 세 가지 기능 인터페이스를 올바르게 구현 Supplier<R>하면 스트림의 요소를 성공적으로 수집할 수 있다는 점에 유의해야 합니다 .BiConsumer<R, ? super T>BiConsumer<R, R>

max(비교기<? super T> 비교기)

max(Comparator<? super T> comparator) 메소드는 지정된 Comparator에 따라 요소를 비교하여 이 스트림에서 가장 큰 요소를 반환하는 종료 작업입니다. 반환된 유형은 Optional<T>이거나, 스트림이 비어 있는 경우 빈 Optional 객체입니다.

가장 큰 요소를 찾으려면 전체 스트림에 대해 비교 작업을 수행해야 하기 때문에 이 방법은 유한 길이의 스트림에서만 사용할 수 있습니다. 이 메서드 실행의 시간 복잡도는 O(n)입니다. 여기서 n은 스트림의 요소 수입니다.

구체적인 사용법은 다음과 같습니다.

여러 요소를 포함하는 Stream 개체를 만듭니다.

max(Comparator<? super T> comparator) 메소드를 호출하고 Comparator 객체를 전달합니다.

이 방법은 전체 스트림에 대해 비교 작업을 수행하고 가장 큰 요소를 찾습니다.

반환 유형은 Optional<T>이며, 그 값은 .get() 메서드를 통해 얻을 수 있습니다.

예를 들어, 다음 코드는 max() 메서드를 사용하여 스트림에서 가장 큰 요소를 찾는 방법을 보여줍니다.
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> max = list.stream().max(Integer::compare);
if(max.isPresent()) {
    System.out.println("The maximum element is " + max.get());
}
출력은 다음과 같습니다. "최대 요소는 5입니다. 왜냐하면 5가 목록에서 가장 큰 요소이기 때문입니다. max() 메소드는 Optional 객체를 반환하므로 다른 작업을 수행하기 전에 최대값이 있는지 확인해야 합니다.

min(비교기<? super T> 비교기)

min(Comparator<? super T> comparator) 메서드는 지정된 Comparator에 따라 요소를 비교하여 이 스트림에서 가장 작은 요소를 반환하는 종료 작업입니다. 반환된 유형은 Optional<T>이거나, 스트림이 비어 있는 경우 빈 Optional 객체입니다.

이 방법은 유한한 길이의 스트림에서만 사용할 수 있습니다. 왜냐하면 가장 작은 요소를 찾으려면 전체 스트림에 대해 비교 작업을 수행해야 하기 때문입니다. 이 메서드 실행의 시간 복잡도는 O(n)입니다. 여기서 n은 스트림의 요소 수입니다.

구체적인 사용법은 다음과 같습니다.

여러 요소를 포함하는 Stream 개체를 만듭니다.

min(Comparator<? super T> comparator) 메소드를 호출하고 Comparator 객체를 전달합니다.

이 방법은 전체 스트림에 대해 비교 작업을 수행하고 가장 작은 요소를 찾습니다.

반환 유형은 Optional<T>이며, 그 값은 .get() 메서드를 통해 얻을 수 있습니다.

예를 들어, 다음 코드는 min() 메서드를 사용하여 스트림에서 가장 작은 요소를 찾는 방법을 보여줍니다.
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> min = list.stream().min(Integer::compare);
if(min.isPresent()) {
    System.out.println("The minimum element is " + min.get());
}
출력은 다음과 같습니다. "최소 요소는 1입니다. 1이 목록의 최소 요소이기 때문입니다. min() 메소드는 Optional 객체를 반환하므로 다른 작업을 수행하기 전에 최소값이 있는지 확인해야 합니다.

세다()

count()method는 스트림의 요소 수를 계산하는 데 사용되는 방법입니다.

다음은 사용 예입니다.
import java.util.Arrays;
import java.util.List;

public class StreamCountExample {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        
        long count = list.stream().count();
        System.out.println("Count: " + count); // 输出 Count: 5
    }
}
위의 코드는 메서드를 사용하여 count()스트림의 요소 수를 계산하는 방법을 보여줍니다. 먼저 정수 목록이 생성된 list다음 stream()메서드에 의해 스트림으로 변환됩니다. 그런 다음 count()메서드를 사용하여 스트림의 요소 수를 가져오고 긴 정수 값을 가져온 count다음 마지막으로 인쇄합니다.

count()이 메서드는 스트림의 요소 수를 나타내는 긴 값을 반환한다는 점에 유의해야 합니다 . 스트림이 비어 있으면 반환 값은 0입니다. 또한 count()메서드는 종료 작업을 반환하므로 이 메서드를 호출한 후에는 동일한 스트림에서 다른 작업을 수행할 수 없습니다.

allMatch(술어<? super T> 술어)

allMatch(Predicate<? super T> predicate)이 메소드는 스트림의 모든 요소가 지정된 조건을 충족하는지 여부를 판단하고 모두 충족하면 반환하고 true, 그렇지 않으면 반환하는 데 사용됩니다 false. Predicate매개변수는 T 유형의 매개변수를 승인하고 부울 유형의 결과를 리턴하는 판단 조건입니다.

allMatch()다음은 이 메서드의 사용 예 입니다 .
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

// 判断是否所有元素都大于 0
boolean allPositive = list.stream()
        .allMatch(x -> x > 0);

System.out.println(allPositive); // true

// 判断是否所有元素都小于 3
boolean allLessThanThree = list.stream()
        .allMatch(x -> x < 3);

System.out.println(allLessThanThree); // false
위 코드에서는 먼저 1부터 5까지의 정수 리스트를 생성한 후, allMatch()리스트에 있는 요소들이 모두 0보다 큰지, 3보다 작은지를 판단하는 메소드를 사용하여 그 결과를 콘솔에 출력한다.

스트림이 비어 있으면 allMatch()메서드가 반환된다는 점에 유의하세요 true.

anyMatch(술어<? super T> 술어)

anyMatch(Predicate<? super T> predicate)스트림에 지정된 조건을 만족하는 요소가 하나 이상 있는지 판단하여 존재하면 반환하고 true, 없으면 반환하는 메서드입니다 false. Predicate매개변수는 T 유형의 매개변수를 승인하고 부울 유형의 결과를 리턴하는 판단 조건입니다.

anyMatch()다음은 이 메서드의 사용 예 입니다 .
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

// 判断是否存在大于 3 的元素
boolean existsGreaterThanThree = list.stream()
        .anyMatch(x -> x > 3);

System.out.println(existsGreaterThanThree); // true

// 判断是否存在小于 0 的元素
boolean existsLessThanZero = list.stream()
        .anyMatch(x -> x < 0);

System.out.println(existsLessThanZero); // false
위 코드에서는 1부터 5까지의 정수 리스트를 먼저 생성한 후, anyMatch()그 리스트에 3보다 큰 원소와 0보다 작은 원소가 있는지 판단하고 그 결과를 콘솔에 출력하는 메소드를 사용한다.

스트림이 비어 있으면 anyMatch()메서드가 반환된다는 점에 유의하세요 false.

noneMatch(술어<? super T> 술어)

noneMatch(Predicate<? super T> predicate) 메서드는 스트림의 모든 요소가 지정된 Predicate 조건을 충족하지 않는지 확인하는 종료 작업입니다. 조건을 만족하는 요소가 하나도 없으면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

이 메서드 실행의 시간 복잡도는 O(n)입니다. 여기서 n은 스트림의 요소 수입니다.

구체적인 사용법은 다음과 같습니다.

여러 요소를 포함하는 Stream 개체를 만듭니다.

noneMatch(Predicate<? super T> predicate) 메서드를 호출하고 Predicate 객체를 전달합니다.

이 메소드는 전체 스트림에 대해 검사 작업을 수행하고 모든 요소가 조건에 실패하는지 여부를 나타내는 부울을 반환합니다.

예를 들어, 다음 코드는 noneMatch() 메서드를 사용하여 스트림의 모든 요소가 짝수인지 확인하는 방법을 보여줍니다.
List<Integer> list = Arrays.asList(1, 3, 5, 7);
boolean result = list.stream().noneMatch(x -> x % 2 == 0);
if(result) {
    System.out.println("All the elements are odd numbers.");
} else {
    System.out.println("There are even numbers in the list.");
}
출력은 다음과 같습니다: "모든 요소는 홀수입니다." 왜냐하면 주어진 목록에 짝수가 없기 때문입니다. 목록에 짝수 숫자가 있으면 "목록에 짝수 숫자가 있습니다."가 출력됩니다.

찾기Any()

findAny()메서드는 현재 스트림의 모든 요소를 반환하는 데 사용됩니다. filter()기준에 일치하는 요소가 발견되자마자 반환하는 메서드와 함께 사용할 수 있습니다 .

다음은 사용 예입니다.
import java.util.Arrays;
import java.util.List;

public class StreamFindAnyExample {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        
        Integer result = list.stream()
                             .filter(n -> n % 2 == 0)
                             .findAny()
                             .orElse(null);

        System.out.println(result); // 输出 2 或 4
    }
}
위의 코드는 findAny()메서드를 사용하여 현재 스트림의 요소를 반환하는 방법을 보여줍니다. 먼저 정수 목록이 생성된 list다음 stream()메서드에 의해 스트림으로 변환됩니다. 다음으로, filter(n -> n % 2 == 0)메서드를 사용하여 짝수 요소만 포함하는 새 스트림을 가져오고, findAny()해당 메서드를 사용하여 요소 중 하나를 반환합니다. 스트림에 짝수 요소가 여러 개 있으므로 반환 값은 2 또는 4일 수 있습니다. 마지막으로 orElse(null)반환 값은 메서드에 의해 처리되어 인쇄됩니다.

스트림에 요소가 없으면 findAny()메서드는 빈 개체를 반환합니다 Optional. 따라서 위 코드에서는 orElse(null)null일 수 있는 반환 값이 메서드에 의해 처리됩니다.

첫 번째 찾기()

findFirst()메서드는 현재 스트림의 첫 번째 요소를 반환하는 데 사용됩니다. filter()기준에 일치하는 요소가 발견되자마자 반환하는 메서드와 함께 사용할 수 있습니다 .

다음은 사용 예입니다.

import java.util.Arrays;
import java.util.List;

public class StreamFindFirstExample {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        
        Integer result = list.stream()
                             .filter(n -> n % 2 == 0)
                             .findFirst()
                             .orElse(null);

        System.out.println(result); // 输出 2
    }
}

위의 코드는 findFirst()메서드를 사용하여 현재 스트림의 첫 번째 요소를 반환하는 방법을 보여줍니다. 먼저 정수 목록이 생성된 list다음 stream()메서드에 의해 스트림으로 변환됩니다. 다음으로, filter(n -> n % 2 == 0)메서드를 사용하여 짝수 요소만 포함하는 새 스트림을 가져오고 findFirst()이 메서드를 사용하여 그 안에 있는 첫 번째 요소를 반환합니다. 스트림에 짝수 요소가 여러 개 있으므로 반환 값은 2입니다. 마지막으로 orElse(null)반환 값은 메서드에 의해 처리되어 인쇄됩니다.

스트림에 요소가 없으면 findFirst()메서드는 빈 개체를 반환합니다 Optional. 따라서 위 코드에서는 orElse(null)null일 수 있는 반환 값이 메서드에 의해 처리됩니다. 또한 스트림의 요소가 순서가 지정되지 않은 경우 해당 요소 중 하나가 반환됩니다.