La búsqueda es una operación común para cuando se tiene un conjunto de datos.
El Stream API tiene dos tipos de funcionamiento para la búsqueda.
Métodos que empiezan con Encuentra :
12Opcional<T¡;FindAny()Opcional<T¡;FindFirst()
java
métodos de búsqueda de un elemento en un arroyo. Dado que existe la posibilidad de que no se pueda encontrar un elemento (si el arroyo está vacío, por ejemplo), los métodos de búsqueda devuelven un Opcional.
La otra forma de buscar es a través de métodos que terminan con Coincidencia :
123booleanallMatch(Predicate<?superT> predicate)booleananyMatch(Predicate<?superT> predicate)booleannoneMatch(Predicate<?superT> predicate)
java
Los métodos de concordancia indican si un determinado elemento coincide con el predicado dado. Devuelven un booleano.
findAny() y findFirst() prácticamente hacen lo mismo, devuelven el primer elemento que encuentran en un flujo:
1234567IntStream stream =IntStream.of(1,2,3,4,5,6,7);stream.findFirst().ifPresent(System.out::println);// 1IntStream stream2 =IntStream.of(1,2,3,4,5,6,7);stream2.findAny().ifPresent(System.out::println);// 1
java
Una vez más, si el arroyo está vacío, estos devuelven un Opcional vacío:
1234Stream<String> stream =Stream.empty();System.out.println( stream.findAny().isPresent());// false
java
java.util. Opcional es una nueva clase también introducida en Java 8. (Si quieres saber más sobre ella, mira mi tutorial aquí.)
¿Cuándo usar findAny() y cuándo usar findFirst()?
Cuando se trabaja con corrientes paralelas, es más difícil encontrar el primer elemento. En este caso, es mejor usar findAny() si no te importa realmente qué elemento se devuelve.
Por otro lado, tenemos los métodos de *Match*.
anyMatch() devuelve true si alguno de los elementos de una corriente coincide con el predicado dado:
1234IntStream stream =IntStream.of(1,2,3,4,5,6,7);System.out.println( stream.anyMatch(i -> i%3==0));// true
java
Si la corriente está vacía o si no hay ningún elemento que coincida, este método devuelve falso:
123456789IntStream stream =IntStream.empty();System.out.println( stream.anyMatch(i -> i%3==0));// falseIntStream stream2 =IntStream.of(1,2,3,4,5,6,7);System.out.println( stream2.anyMatch(i -> i%10==0));// false
java
allMatch() devuelve true sólo si todos los elementos de la corriente coinciden con el predicado dado:
123456789IntStream stream =IntStream.of(1,2,3,4,5,6,7);System.out.println( stream.allMatch(i -> i >0));// trueIntStream stream2 =IntStream.of(1,2,3,4,5,6,7);System.out.println( stream2.allMatch(i -> i%3==0));// false
java
Si la corriente está vacía, este método devuelve verdadero sin evaluar el predicado:
1234IntStream stream =IntStream.empty();System.out.println( stream.allMatch(i -> i%3==0));// true
java
noneMatch() es lo opuesto a allMatch(), devuelve true si ninguno de los elementos de la corriente coinciden con el predicado dado:
1234567891011121314IntStream stream =IntStream.of(1,2,3,4,5,6,7);System.out.println( stream.noneMatch(i -----; i >0));// falseIntStream stream2 =IntStream.of(1,2,3,4,5,6,7);System. out.println( stream2.noneMatch(i - > i%3==0));// falseIntStream stream3 =IntStream.of(1,2,3,4,5,6,7);System.out.println( stream3.noneMatch(i -> i >10));// true
java
Si la corriente está vacía, este método devuelve también verdadero sin evaluar el predicado:
1234IntStream stream =IntStream.empty();System.out.println( stream.noneMatch(i -> i%3==0));// true
java
Una cosa importante a considerar es que todas estas operaciones usan algo similar al cortocircuito de los operadores.
El cortocircuito significa que la evaluación se detiene una vez que se encuentra un resultado. Así, las operaciones de búsqueda* se detienen en el primer elemento encontrado.
Sin embargo, con las operaciones de *Match, ¿por qué evaluar todos los elementos de una corriente cuando, al evaluar el tercer elemento (por ejemplo), se puede saber si todos o ninguno (de nuevo por ejemplo) de los elementos coincidirán?