Operaciones intermedias con Streams: filter()

Dentro del paradigma de la programación funcional en Java, las operaciones con Streams representan un punto crucial para la manipulación eficiente de datos. Los Streams, introducidos en Java 8, representan una secuencia de elementos sobre los que se pueden realizar una serie de operaciones, como transformaciones, filtrado, agrupación, entre otras. En este documento se profundizará en una de estas operaciones intermedias, específicamente filter().

El método filter() es una operación intermedia que permite procesar elementos de un Stream en función de una condición. Este método toma como argumento un Predicate, que es una interfaz funcional que define una condición de tipo booleana. Si un elemento del Stream satisface esta condición, se incluirá en el Stream resultante. Si no la satisface, se omitirá.

Es importante notar que filter() es una operación intermedia, lo que significa que no se ejecutará hasta que se invoque una operación final sobre el Stream. Además, las operaciones intermedias son "lazy", es decir, solo procesan los elementos que son necesarios para el resultado de la operación final.

Sintaxis

La sintaxis de la operación filter() es bastante sencilla. Se utiliza de la siguiente manera:

stream.filter(condicion);

La condicion es un Predicate, es decir, una función que toma un elemento del Stream y devuelve un valor booleano.

Ejemplo Básico

Supongamos que se tiene una lista de números y se quiere obtener solo los números pares. Esto se puede lograr fácilmente con la operación filter():

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

Stream<Integer> streamNumerosPares = numeros.stream()
    .filter(numero -> numero % 2 == 0);

streamNumerosPares.forEach(System.out::println);

En este código, se crea un Stream a partir de la lista de números y luego se filtra con filter(). El Predicate utilizado es numero -> numero % 2 == 0, que es una expresión lambda que verifica si un número es par. Luego, el Stream resultante se imprime con la operación final forEach().

Operadores

Aunque filter() toma como argumento un Predicate, este puede ser cualquier función que tome un elemento del Stream y devuelva un booleano. Por lo tanto, es posible usar cualquier operador que devuelva un booleano, como ==, !=, <, >, <=, >=, entre otros.

Por ejemplo, si se quisiera obtener los números menores que 5 de la lista anterior, se podría hacer lo siguiente:

Stream<Integer> streamNumerosMenoresQue5 = numeros.stream()
    .filter(numero -> numero < 5);

streamNumerosMenoresQue5.forEach(System.out::println);

Combinando filtros

Es posible combinar varios filtros para lograr condiciones más complejas. Por ejemplo, si se quisiera obtener los números pares menores que 5, se podría hacer lo siguiente:

Stream<Integer> streamNumerosParesMenoresQue5 = numeros.stream()
    .filter(numero -> numero % 2 == 0)
    .filter(numero -> numero < 5);

streamNumerosParesMenoresQue5.forEach(System.out::println);

En este código, primero se filtran los números pares y luego, sobre ese resultado, se filtran los números menores que 5.

Filtros con objetos

Los filtros no se limitan a los tipos de datos primitivos, también se pueden aplicar a objetos. Supongamos que se tiene una lista de objetos Persona y se quiere obtener las personas mayores de 18 años. Podríamos hacerlo de la siguiente manera:

List<Persona> personas = // obtener lista de personas

Stream<Persona> streamPersonasMayores = personas.stream()
    .filter(persona -> persona.getEdad() > 18);

streamPersonasMayores.forEach(System.out::println);

En este código, la condición del filtro es persona -> persona.getEdad() > 18, que obtiene la edad de cada persona y verifica si es mayor que 18.

Conclusión

La operación filter() es una herramienta poderosa para procesar Streams en Java. Permite aplicar condiciones a los elementos de un Stream, generando un nuevo Stream que solo contiene los elementos que satisfacen estas condiciones. Esto permite manipular y transformar los datos de manera eficiente, y es una parte esencial del paradigma de programación funcional en Java.

Sin embargo, es importante recordar que filter() es una operación intermedia y "lazy", y por lo tanto no se ejecutará hasta que se invoque una operación final sobre el Stream. Además, filter() no modifica el Stream original, sino que crea un nuevo Stream con los elementos filtrados.

El uso de filter() puede hacer que el código sea más legible y fácil de entender, ya que permite expresar las operaciones de procesamiento de datos de una manera declarativa, en lugar de tener que usar bucles y condiciones explícitas. Es importante, sin embargo, tener en cuenta el rendimiento, ya que el procesamiento de Streams puede ser más lento que las operaciones tradicionales con bucles, especialmente para grandes volúmenes de datos.