Ejemplo de uso del método de operación final y explicación detallada de Java8 Stream (3)

La operación final se refiere a la operación que finaliza el procesamiento del Stream y desencadena la ejecución del Stream. Los siguientes son algunos métodos de operación final comúnmente utilizados. La operación final atraviesa la fuente de datos y, por lo tanto, se evalúa tempranamente.

Explicación detallada de Java8 Stream y ejemplos de uso de métodos de operación intermedia (1)
Explicación detallada de Java8

forEach(Consumer<T> action): realiza la acción especificada en cada elemento de la secuencia.

toArray(): convierte los elementos de la secuencia en una matriz.

reducir (identidad T, acumulador BinaryOperator<T>): agrega los elementos en la secuencia utilizando el acumulador especificado.

recopilar (Collector <T, A, R> recopilador): recopila los elementos de la secuencia en un contenedor.

min(Comparator<T> comparador): devuelve el elemento más pequeño de la secuencia.

max(Comparator<T> comparador): devuelve el elemento más grande de la secuencia.

count(): Devuelve el número de elementos en la secuencia.

anyMatch (Predicado <T> predicado): determina si algún elemento de la secuencia coincide con la condición especificada.

allMatch (Predicado <T> predicado): determina si todos los elementos de la secuencia coinciden con la condición especificada.

noneMatch (Predicado <T> predicado): determina si algún elemento de la secuencia coincide con la condición especificada.

findFirst(): Devuelve el primer elemento de la secuencia.

findAny(): devuelve cualquier elemento de la secuencia.

Ejemplo detallado del método de operación final de transmisión

paraCada(Consumidor<? super T> acción)

forEach()El método es Streamun método de acción final en la clase que recibe una Consumerfunción como argumento para realizar la acción especificada en cada elemento de la secuencia. forEach()El método atraviesa toda la secuencia y realiza la operación especificada en cada elemento, y el orden de las operaciones se realiza en el orden de la secuencia.

Por ejemplo, supongamos que hay una lista que contiene varias cadenas y ahora cada cadena debe convertirse a letras minúsculas y generarse, puede usar forEach()el método para lograr:
List<String> strList = Arrays.asList("Java", "Stream", "API");
strList.stream()
       .map(String::toLowerCase)
       .forEach(System.out::println);
En el código anterior, primero cree uno de la lista de cadenas Stream, luego ejecute String::toLowerCaseel método en cada cadena, es decir, convierta la cadena a letras minúsculas y finalmente forEach()ejecute la operación en cada elemento a través del método System.out::println, es decir, envíe el elemento a la consola.

Tenga en cuenta que, dado que forEach()el método es un método de acción final, no puede devolver ningún valor. Si necesita convertir los elementos de la secuencia a otro objeto, como una colección o una matriz, puede utilizar collect()el método. Al mismo tiempo, dado que forEach()el método es una operación terminal, ya no se pueden realizar operaciones continuas en el mismo flujo y es necesario recrear un nuevo flujo para la operación.

Además, debido a que forEach()el método es una operación de bloqueo, puede crear problemas de rendimiento cuando se manejan grandes cantidades de datos. Si es necesario realizar operaciones en paralelo para lograr la eficiencia del procesamiento, se puede utilizar forEachOrdered()el método o método. El método es similar al método, pero garantiza que los elementos se procesen en el orden original; el método puede convertir el flujo en un flujo paralelo, realizando operaciones en paralelo en procesadores de múltiples núcleos.parallelStream()forEachOrdered()forEach()parallelStream()

forEachOrdered(Consumidor<? super T> acción)

forEachOrdered()El método es Streamun método de operación final en la clase, que recibe una Consumerfunción como parámetro, que se utiliza para realizar la operación especificada en cada elemento de la secuencia, forEach()similar al método. La diferencia es que forEachOrdered()se garantiza que los métodos ejecutarán operaciones secuencialmente en el orden original de los elementos de la secuencia.

Por ejemplo, supongamos que hay una lista que contiene varias cadenas y ahora cada cadena debe convertirse a letras minúsculas y generarse. El orden de salida debe ser coherente con el orden original, lo que se puede lograr mediante el método forEachOrdered():
List<String> strList = Arrays.asList("Java", "Stream", "API");
strList.stream()
       .map(String::toLowerCase)
       .forEachOrdered(System.out::println);
En el código anterior, primero cree uno de la lista de cadenas Stream, luego ejecute String::toLowerCaseel método en cada cadena, es decir, convierta la cadena a letras minúsculas y finalmente forEachOrdered()ejecute la operación en cada elemento a través del método System.out::println, es decir, envíe el elemento a la consola. Desde que se llamó al método forEachOrdered(), el orden de salida sigue siendo el mismo que el orden original.

Tenga en cuenta que, dado que forEachOrdered()el método es un método de acción final, no puede devolver ningún valor. Si necesita convertir los elementos de la secuencia a otro objeto, como una colección o una matriz, puede utilizar collect()el método. Además, dado que forEachOrdered()el método es una operación de bloqueo, puede causar problemas de rendimiento al manejar grandes cantidades de datos. Si necesita ejecutar operaciones en paralelo para mejorar la eficiencia del procesamiento, puede utilizar parallelStream()el método.

a matriz()

El método toArray() es una operación de terminación que convierte los elementos del objeto Stream en una matriz y lo devuelve. Este método no recibe ningún parámetro y devolverá una matriz de tipo Objeto, que se puede convertir mediante inferencia de tipos genéricos.

El uso específico es el siguiente:

Cree un objeto Stream que contenga varios elementos.

Llame al método toArray().

Este método convierte los elementos del objeto Stream en una matriz de tipo Objeto y devuelve la matriz.

Por ejemplo, el siguiente código demuestra cómo utilizar el método toArray() para convertir elementos de una secuencia de cadenas en una matriz:
List<String> list = Arrays.asList("apple", "banana", "orange", "pear");
Object[] array = list.stream().toArray();
System.out.println(Arrays.toString(array)); // 输出 [apple, banana, orange, pear]
El código anterior crea una lista de tipos de String y la convierte en un objeto Stream. A continuación, se llama al método toArray(), que convierte los elementos del objeto Stream en una matriz de tipo Objeto y devuelve la matriz. Finalmente, use el método Arrays.toString() para convertir la matriz en una cadena y enviarla a la consola.

Cabe señalar que dado que el método toArray() devuelve una matriz de tipo Objeto, es necesario utilizar la inferencia de tipos genérica para la conversión de tipos forzada. Por ejemplo, si desea convertir un elemento de tipo String en una matriz de tipo String, puede utilizar el siguiente código:
String[] strArray = list.stream().toArray(String[]::new);
Aquí, usamos la forma de referencia de método y pasamos el constructor String[]::new como parámetro al método toArray(), para convertir la matriz de tipo Objeto en una matriz de tipo Cadena.

toArray(IntFunction<A[]> generador)

El método toArray(IntFunction<A[]> generador) es una operación de terminación para convertir los elementos del objeto Stream en una nueva matriz del tipo especificado y devolverlo. Este método recibe una función IntFunction como parámetro, que se utiliza para crear una nueva matriz del tamaño especificado para acomodar todos los elementos en el objeto Stream.

El uso específico es el siguiente:

Cree un objeto Stream que contenga varios elementos.

Llame al método toArray(IntFunction<A[]> generador) y pase una función IntFunction.

Este método utilizará la función IntFunction para crear una nueva matriz del tamaño especificado y convertir los elementos del objeto Stream en la matriz.

Por ejemplo, el siguiente código demuestra cómo utilizar el método toArray() y una expresión Lambda para convertir elementos de una secuencia de cadenas en una matriz de tipo 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]
El código anterior crea una lista de tipos de String y la convierte en un objeto Stream. Luego llame al método toArray() y pase una expresión Lambda que cree una matriz de tipo String según el tamaño dado. Este método utilizará una expresión Lambda para crear una nueva matriz y convertir los elementos del objeto Stream en la matriz. Finalmente, use el método Arrays.toString() para convertir la matriz en una cadena y enviarla a la consola.

Cabe señalar que, dado que necesitamos crear una matriz de un tipo específico, debemos usar genéricos y realizar la conversión de tipos. En el ejemplo anterior, utilizamos la expresión Lambda (tamaño -> nueva cadena [tamaño]) para crear una nueva matriz de tipo Cadena. Según el valor del tamaño, esta expresión devolverá una matriz de tipo Cadena del tamaño especificado.

reducir(BinaryOperator<T> acumulador)

El método reduce(BinaryOperator<T> accumulator) es una operación de terminación que reduce todos los elementos a un único resultado. Este método recibe una función BinaryOperator como parámetro, que se utiliza para realizar la operación de acumulación en los elementos de la secuencia.

El uso específico es el siguiente:

Cree un objeto Stream que contenga varios elementos.

Llame al método reduce(BinaryOperator<T> accumulator) y pase una función BinaryOperator.

Este método realizará la operación de acumulación especificada en toda la secuencia y devolverá un objeto Opcional que contiene el resultado.

Por ejemplo, el siguiente código demuestra cómo utilizar el método reduce() para calcular la suma de todos los elementos en una lista de números enteros:
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
El código anterior crea una lista de tipo Integer y la convierte en un objeto Stream. Luego llame al método reduce(), que realiza la operación de acumulación en cada elemento y devuelve un objeto opcional que contiene el resultado. Finalmente, use el método ifPresent() para imprimir el resultado, porque el método reduce() devuelve un objeto Opcional para evitar excepciones de puntero nulo.

Además de la versión anterior reduce(BinaryOperator<T> accumulator) sin un valor inicial, también hay una versión reduce(T Identity, BinaryOperator<T> accumulator) que contiene un valor inicial. La identidad del primer parámetro en este método representa el valor inicial. valor Se pueden evitar excepciones de puntero nulo y el resultado al principio es el valor inicial. Por ejemplo, el siguiente código demuestra cómo utilizar el método reduce() con un valor inicial para calcular la suma de todos los elementos en una lista de números enteros:
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
El código anterior crea una lista de tipo Integer y la convierte en un objeto Stream. Luego llame al método reduce(), especifique un valor inicial de 0, realice una operación de acumulación en cada elemento y devuelva el resultado final. El resultado se imprime al final, porque el método reduce() devuelve tipos de datos primitivos.

reducir (identidad U, acumulador BiFunction<U,? super T,U>, combinador BinaryOperator<U>)

El método reduce(U identidad, BiFunction<U,? super T, U> acumulador, BinaryOperator<U> combinador) es una operación de terminación que reduce todos los elementos en un solo resultado. Este método recibe tres parámetros: el primer parámetro es la identidad del valor inicial, el segundo parámetro es la función BiFunction, que se utiliza para convertir cada elemento en un determinado tipo U y realizar operaciones acumulativas con el resultado parcial anterior, y el tercero El El parámetro es la función BinaryOperator, que se utiliza para combinar todos los resultados parciales para obtener el resultado final.

El uso específico es el siguiente:

Cree un objeto Stream que contenga varios elementos.

Llame al método reduce(U identidad, BiFunction<U,? super T, U> acumulador, BinaryOperator<U> combinador) y pase un valor inicial, una función BiFunction y una función BinaryOperator.

Este método realizará la operación de acumulación especificada en toda la secuencia y devolverá el resultado.

Por ejemplo, el siguiente código demuestra cómo utilizar el método reduce() para calcular la suma de las longitudes de todos los elementos en una lista de cadenas:
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
El código anterior crea una lista de tipos de String y la convierte en un objeto Stream. Luego llame al método reduce(), especifique un valor inicial de 0, agregue la longitud de cada elemento al valor inicial y use el método Integer::sum para combinar todos los resultados parciales. Finalmente, imprima el resultado, debido a que el método reduce () devuelve el tipo de datos básico, no es necesario utilizar el método isPresent () para determinar si el resultado existe.

Cabe señalar que dado que este método se puede operar en paralelo, cada resultado parcial debe acumularse usando la función BiFunction y el resultado final debe combinarse usando la función BinaryOperator. Si hay varios resultados parciales en la secuencia, se llama a la función BinaryOperator para combinarlos en un solo resultado.

recoger(Coleccionista<? super T,A,R> coleccionista)

collect(Collector<? super T,A,R> collector)El método es un método proporcionado por la interfaz en Java 8 Streampara recopilar los elementos de la secuencia en un objeto contenedor. Este método recibe un Collectorobjeto como parámetro, que define cómo recopilar los elementos en la secuencia y colocar el resultado en un objeto contenedor.

A continuación se muestra un ejemplo de uso:
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"
    }
}
El código anterior muestra cuatro collect()ejemplos del uso de . En el primer ejemplo, utilícelo Collectors.toList()para recopilar cadenas en la secuencia que comienzan con la letra "M" en un Listobjeto. En el segundo ejemplo, Collectors.toCollection(ArrayList::new)recopile los primeros 10 números enteros de la secuencia en un ArrayListobjeto usando . En el tercer ejemplo, use Collectors.summingInt(Integer::intValue)calcula la suma de los números enteros en la secuencia. En el cuarto ejemplo, utilícelo Collectors.joining(", ")para concatenar las cadenas de la secuencia en una sola cadena.

Al utilizar collect()el método, debe prestar atención a Collectorla definición del objeto, que define la forma de recopilar elementos de la secuencia. Las clases de implementación más utilizadas Collectorson toList(), toSet(), , etc., que se pueden seleccionar según las necesidades específicas toMap().summingInt()joining()

recoger (Proveedor<R> proveedor, BiConsumer<R,? acumulador super T>, combinador BiConsumer<R,R>)

collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner)El método es un método proporcionado por la interfaz en Java 8 Streampara recopilar los elementos de la secuencia en un objeto contenedor. Este método recibe tres parámetros:

supplier: proporciona un método de fábrica para objetos contenedores.

accumulator: una función de acumulador que recopila elementos en una secuencia.

combiner: Una función que fusiona dos objetos contenedores en uno.

A continuación se muestra un ejemplo de uso:
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]
    }
}
El código anterior muestra collect()un ejemplo de colección personalizada utilizando el método. Primero, se crea un objeto ArrayListcomo objeto contenedor y se agregan algunas cadenas al objeto. Luego stream()obtenga la transmisión a través del método y collect()realice una recopilación personalizada a través del método.

Durante esta colección, úselo ArrayList::newpara proporcionar un ArrayListmétodo de fábrica para crear objetos contenedores; úselo para (l, s) -> {...}definir una función acumuladora en la que solo se agregan cadenas que comienzan con la letra "M" al objeto contenedor; úselo para definir List::addAllun objeto contenedor de fusión Función que combina el elementos de múltiples objetos contenedores en uno. Al final, obtendrá una lista que contiene cadenas que comienzan con la letra "M".

Cabe señalar que cuando se utiliza collect()el método, se deben seleccionar diferentes métodos de recopilación de acuerdo con las necesidades específicas Supplier<R>y BiConsumer<R, ? super T>la implementación correcta BiConsumer<R, R>de las tres interfaces de funciones puede recopilar elementos con éxito en la secuencia.

max(Comparador<? super T> comparador)

El método max(Comparator<? super T> comparador) es una operación de terminación que devuelve el elemento más grande en esta secuencia, comparando elementos según el Comparador especificado. El tipo devuelto es Opcional<T>, o un objeto Opcional vacío si la secuencia está vacía.

Este método solo se puede utilizar en secuencias de longitud finita, porque es necesario realizar operaciones de comparación en toda la secuencia para encontrar el elemento más grande. La complejidad temporal de la ejecución de este método es O (n), donde n es el número de elementos en la secuencia.

El uso específico es el siguiente:

Cree un objeto Stream que contenga varios elementos.

Llame al método max(Comparator<? super T> comparador) y pase un objeto Comparator.

Este método realizará una operación de comparación en todo el flujo y encontrará el elemento más grande.

El tipo de retorno es Opcional <T> y el valor que contiene se puede obtener mediante el método .get().

Por ejemplo, el siguiente código demuestra cómo utilizar el método max() para encontrar el elemento más grande en una secuencia:
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());
}
El resultado es: "El elemento máximo es 5", porque 5 es el elemento más grande de la lista. Tenga en cuenta que el método max() devuelve un objeto opcional, por lo que es necesario determinar si existe un valor máximo antes de realizar otras operaciones.

min(Comparador<? super T> comparador)

El método min(Comparator<? super T> comparador) es una operación de terminación que devuelve el elemento más pequeño en esta secuencia, comparando elementos de acuerdo con el Comparador especificado. El tipo devuelto es Opcional<T>, o un objeto Opcional vacío si la secuencia está vacía.

Este método solo se puede utilizar en secuencias de longitud finita, porque las operaciones de comparación deben realizarse en toda la secuencia para encontrar el elemento más pequeño. La complejidad temporal de la ejecución de este método es O (n), donde n es el número de elementos en la secuencia.

El uso específico es el siguiente:

Cree un objeto Stream que contenga varios elementos.

Llame al método min(Comparator<? super T> comparador) y pase un objeto Comparator.

Este método realizará una operación de comparación en todo el flujo y encontrará el elemento más pequeño.

El tipo de retorno es Opcional <T> y el valor que contiene se puede obtener mediante el método .get().

Por ejemplo, el siguiente código demuestra cómo utilizar el método min() para encontrar el elemento más pequeño en una secuencia:
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());
}
El resultado es: "El elemento mínimo es 1", porque 1 es el elemento mínimo en la lista. Tenga en cuenta que el método min() devuelve un objeto opcional, por lo que es necesario determinar si existe un valor mínimo antes de realizar otras operaciones.

contar()

count()El método es el método utilizado para contar el número de elementos en la secuencia.

A continuación se muestra un ejemplo de uso:
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
    }
}
El código anterior muestra cómo utilizar count()el método para contar la cantidad de elementos en la secuencia. Primero se crea una lista de números enteros listy luego stream()el método la convierte en una secuencia. Luego, use count()el método para obtener la cantidad de elementos en la secuencia, obtenga un valor entero largo county finalmente imprímalo.

Cabe señalar que count()el método devuelve un valor largo que representa la cantidad de elementos en la secuencia. Si la secuencia está vacía, el valor de retorno es 0. Además, dado que count()el método devuelve una operación de terminación, no se pueden realizar otras operaciones en la misma secuencia después de llamar a este método.

allMatch(Predicado<? super T> predicado)

allMatch(Predicate<? super T> predicate)El método se utiliza para juzgar si todos los elementos de la secuencia cumplen con las condiciones especificadas y devolver si todos las cumplen true; de lo contrario, devolver false. PredicateEl parámetro es una condición de juicio que acepta un parámetro de tipo T y devuelve un resultado de tipo booleano.

A continuación se muestra allMatch()un ejemplo de uso del método:
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
En el código anterior, primero se crea una lista de enteros que contiene del 1 al 5 y luego allMatch()se usa el método para juzgar si todos los elementos de la lista son mayores que 0 o menores que 3 y enviar el resultado a la consola.

allMatch()Tenga en cuenta que el método regresa cuando la secuencia está vacía true.

anyMatch(Predicado<? super T> predicado)

anyMatch(Predicate<? super T> predicate)El método se utiliza para juzgar si hay al menos un elemento en la secuencia que cumple con la condición especificada y devolver si existe true; de lo contrario, devolver false. PredicateEl parámetro es una condición de juicio que acepta un parámetro de tipo T y devuelve un resultado de tipo booleano.

A continuación se muestra anyMatch()un ejemplo de uso del método:
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
En el código anterior, primero se crea una lista de enteros que contiene del 1 al 5, y luego anyMatch()el método se usa para juzgar si hay elementos mayores que 3 y elementos menores que 0 en la lista, y enviar los resultados a la consola.

anyMatch()Tenga en cuenta que el método regresa cuando la secuencia está vacía false.

noneMatch(Predicado<? super T> predicado)

El método noneMatch(Predicate<? super T> predicate) es una operación de terminación que comprueba si todos los elementos de la secuencia no satisfacen la condición de predicado especificada. Devuelve verdadero si ninguno de los elementos cumple la condición; en caso contrario, devuelve falso.

La complejidad temporal de la ejecución de este método es O (n), donde n es el número de elementos en la secuencia.

El uso específico es el siguiente:

Cree un objeto Stream que contenga varios elementos.

Llame al método noneMatch(Predicate<? super T> predicate) y pase un objeto Predicate.

Este método realizará una operación de verificación en toda la secuencia y devolverá un valor booleano que indica si todos los elementos no cumplen la condición.

Por ejemplo, el siguiente código demuestra cómo utilizar el método noneMatch() para comprobar si todos los elementos de una secuencia son pares:
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.");
}
El resultado es: "Todos los elementos son números impares" porque no hay números pares en la lista dada. Si hay números pares en la lista, el resultado será "Hay números pares en la lista".

encontrar cualquier()

findAny()El método se utiliza para devolver cualquier elemento en la secuencia actual. Se puede filter()utilizar con el método para regresar tan pronto como se encuentre un elemento que coincida con los criterios.

A continuación se muestra un ejemplo de uso:
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
    }
}
El código anterior muestra cómo utilizar findAny()el método para devolver cualquier elemento en la secuencia actual. Primero se crea una lista de números enteros listy luego stream()el método la convierte en una secuencia. A continuación, utilice filter(n -> n % 2 == 0)el método para obtener una nueva secuencia que contenga sólo elementos pares y utilice findAny()el método para devolver cualquiera de los elementos. El valor de retorno puede ser 2 o 4 porque hay varios elementos pares en la secuencia. Finalmente, orElse(null)el método procesa el valor de retorno y lo imprime.

Tenga en cuenta que si no hay elementos en la secuencia, findAny()el método devolverá un Optionalobjeto vacío. Por lo tanto, en el código anterior, orElse(null)el valor de retorno posiblemente nulo lo maneja el método.

encontrarPrimero()

findFirst()El método se utiliza para devolver el primer elemento de la secuencia actual. Se puede filter()utilizar con el método para regresar tan pronto como se encuentre un elemento que coincida con los criterios.

A continuación se muestra un ejemplo de uso:

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
    }
}

El código anterior muestra cómo utilizar findFirst()el método para devolver el primer elemento de la secuencia actual. Primero se crea una lista de números enteros listy luego stream()el método la convierte en una secuencia. A continuación, use filter(n -> n % 2 == 0)el método para obtener una nueva secuencia que contenga solo elementos pares y use findFirst()el método para devolver el primer elemento que contiene. Dado que hay varios elementos pares en la secuencia, el valor de retorno es 2. Finalmente, orElse(null)el método procesa el valor de retorno y lo imprime.

Tenga en cuenta que si no hay elementos en la secuencia, findFirst()el método devolverá un Optionalobjeto vacío. Por lo tanto, en el código anterior, orElse(null)el valor de retorno posiblemente nulo lo maneja el método. Además, si los elementos de la secuencia no están ordenados, se devolverá cualquiera de ellos.