Filtro de Stream en Java

1. Transmitir con los métodos filter() y collect() en Java
2. Transmitir con el método filter() y forEach() en Java
3. Transmitir con filter() y múltiples condiciones en Java
4. Transmitir con filter() y map() en Java
5. Transmitir con el apilamiento de varios métodos filter() en Java

Este tutorial presenta la API de Stream y su método filter() en Java. En Java, una secuencia es una colección de objetos.

Una secuencia no almacena ningún dato y, por lo tanto, no es una estructura de datos. Una secuencia tiene varios métodos que se pueden canalizar para obtener el resultado deseado.

Uno de esos métodos es el método filter. Veremos varios ejemplos usando la operación filter() de este artículo.

Entendamos primero la operación filter(). El método filter() devuelve una nueva secuencia con elementos que coinciden con el predicado que se le pasa como argumento.

En otras palabras, la operación filter() se utiliza para filtrar un Stream entrante y generar un nuevo Stream. La sintaxis de este método es:

Stream<T> filter(Predicate<? super T> predicate)

Un predicado es una interfaz funcional, lo que significa que podemos pasar una función lambda o una referencia de método aquí. Veamos ahora algunos ejemplos.

Transmitir con los métodos filter() y collect() en Java

La operación collect() es un tipo de operación de terminal.

Las operaciones terminales se aplican a una secuencia al final para producir un resultado. Después de aplicar un operador de terminal, la secuencia se consume y ya no se puede consumir.

La operación collect() devuelve la salida de las operaciones intermedias; también se puede utilizar para convertir la salida en la estructura de datos deseada. Mira el ejemplo de abajo.

Supongamos que tenemos una lista de todos los estudiantes de una clase y queremos crear una nueva lista que contenga todos los nombres de los estudiantes excepto uno. Supongamos que un estudiante ha dejado la escuela.

Podemos hacer esto con este código dado.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<String> students = Arrays.asList("Kashish", "Riyan", "Ritu");

    List<String> new_students =
        students.stream().filter(sName -> !"Riyan".equals(sName)).collect(Collectors.toList());

    new_students.forEach(System.out::println);
  }
}

Producción :

Kashish
Ritu

En este código, primero, se crea un Stream de nombres de estudiantes.

Luego, la secuencia se filtra utilizando un predicado: todos los nombres que no sean iguales a Riyan. La operación filter genera un nuevo Stream con todos los elementos que satisfacen este predicado.

El Stream recién creado se convierte luego en una Lista utilizando la operación collect.

Transmitir con el método filter() y forEach() en Java

El método forEach() también es una operación de terminal. Aplica la función pasada como argumento a cada elemento de Stream.

Funciona como un bucle foreach, pero solo funciona para la Stream. Vea el ejemplo a continuación.

Supongamos que queremos imprimir todos los números divisibles por cinco. El siguiente código funciona así.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 11, 10, 25);

    numbers.stream().filter(n -> n % 5 == 0).forEach(System.out::println);
  }
}

Producción :

5
10
25

Transmitir con filter() y múltiples condiciones en Java

Podemos pasar múltiples condiciones a la operación filter() usando operadores lógicos para obtener resultados más refinados. Supongamos que queremos encontrar todos los elementos divisibles por cinco y mayores que diez; vea el ejemplo a continuación.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 11, 10, 25);

    numbers.stream().filter(n -> n % 5 == 0 && n > 10).forEach(System.out::println);
  }
}

Producción :

25

Transmitir con filter() y map() en Java

La operación map() es como la operación forEach().

Aplica una función a cada elemento del Stream. Es una operación intermedia más que una operación terminal.

Supongamos que tenemos que elevar al cuadrado todos los elementos divisibles por 5. Podemos hacerlo canalizando las operaciones filter y map.

Vea el ejemplo a continuación.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 11, 10, 25);

    List<Integer> new_numbers =
        numbers.stream().filter(n -> n % 5 == 0).map(x -> x * x).collect(Collectors.toList());

    new_numbers.forEach(System.out::println);
  }
}

Producción :

25
100
625

En el código anterior, primero, se filtra la lista de enteros. Después de filtrar la lista, cada elemento restante en la secuencia se eleva al cuadrado mediante la operación map().

Por último, convertimos el Stream en la lista y lo almacenamos en la lista new_numbers.

Transmitir con el apilamiento de varios métodos filter() en Java

Podemos apilar el método filter() aplicando uno tras otro para obtener un resultado más refinado.

Supongamos que primero queremos filtrar las cadenas cuya longitud es mayor que tres y luego filtrar las cadenas que contienen stack como una subcadena. Podemos hacer esto usando el siguiente código de ejemplo.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<String> str = Arrays.asList("Hello", "I", "Love", "Delftstack");

    List<String> new_string = str.stream()
                                  .filter(n -> n.length() > 3)
                                  .filter(n -> n.contains("stack"))
                                  .collect(Collectors.toList());

    new_string.forEach(System.out::println);
  }
}

Producción :

Delftstack

Tenga en cuenta que el código anterior es equivalente a usar múltiples condiciones usando el operador &&. Mira abajo:

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<String> str = Arrays.asList("Hello", "I", "Love", "Delftstack");

    List<String> new_string = str.stream()
                                  .filter(n -> n.length() > 3 && n.contains("stack"))
                                  .collect(Collectors.toList());

    new_string.forEach(System.out::println);
  }
}

Producción :

Delftstack