Java 8: Streams

Junto con las expresiones lambda, los Streams son una de las funcionalidades más relevantes de Java 8, y trae consigo una nueva forma de trabajar. Mediante una capa de abstracción, los Streams nos permiten definir la lógica de negocio como un conjunto de funciones que se ejecutan de forma anidada.

De este modo, podemos trabajar con colecciones utilizando el paradigma de programación funcional, que nos permite definir las funciones a ejecutar de una forma mucho más clara y, en cierto modo, lo más parecida posible a como lo haríamos las personas en una situación real.

El siguiente código muestra la lógica de un programa que filtra una lista de enteros, y devuelve el valor más pequeño de la lista, sin tener en cuenta los números pares:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public static void main(String\[\] args) {
    List<Integer> integers = Arrays.asList(3, 12, 21, 4, 2, 7, 5);
    Integer min = integers.get(0);

    for (Integer next : integers) {
        if (next % 2 == 0)
            continue;
        if (next < min) {
            min = next;
        }
    }

    System.out.println(min);
}

Ahora veremos cómo se escribiría este mismo código utilizando Streams.

1
2
3
4
5
6
7
8
9

public static void main(String\[\] args) {
    List<Integer> integers = Arrays.asList(3, 12, 21, 4, 2, 7, 5);

    Optional<Integer> min = integers.stream()
            .filter(integer -> integer % 2 != 0)
            .min(Integer::compareTo);

    System.out.println(min.get());
}

Como se puede observar, el código queda mucho más claro, ya que se organiza por funciones anidadas, que se ejecutan como un flujo de trabajo, generando nuevos _Stream_s a medida que avanzan en la cadena de ejecución.

Elementos de un Stream

Como ya he comentado, los Streams son abstracciones que nos permiten definir operaciones agregadas sobre una fuente de datos utilizando funciones.

Los Streams se componen de tres partes:

• La fuente de datos
• Las operaciones intermedias
• La operación terminal

// Fuente de datos: 1 Stream.of(“Some, Comma, Separated, Values”)

// Operaciones intermedias: 0 -> N .flatMap(string -> Stream.of(string.split(","))) .map(string -> string.trim())

//Operación terminal: 1 .forEach(System.out::println);

Fuentes de datos

La fuente de datos consiste en una colección de datos que pueden ser tratados como una cadena de valores.

Java ofrece distintas fuentes de Streams para ciertas clases:

También podemos utilizar métodos estáticos para crear Streams a partir de datos existentes:

Operaciones intermedias

Las operaciones intermedias son operaciones que se aplican sobre la fuente de Stream definida. Estas operaciones no se ejecutan hasta que no se incluye una operación terminal en la secuencia de operaciones, que es la que causa que la cadena de operaciones se ejecute.

La mayoría de las operaciones intermedias reciben un parámetro (interfaz funcional) que define su comportamiento, generalmente utilizando expresiones lambda. Como resultado, todas las operaciones intermedias devuelven un Stream, para que se puedan seguir concatenando operaciones.

El comportamiento definido para estas operaciones debe ser no interferentes sobre la ejecución del Stream, esto significa que la ejecución de la operación actual no debe afectar al resto. También deben ser stateless, es decir, debe tratar cada ejecución independientemente, sin relacionar las ejecuciones entre sí.

Estos dos patrones de comportamiento permite que un Stream pueda ser ejecutado de forma secuencial o paralela, sin necesidad de modificaciones, y definiendo su comportamiento en tiempo de ejecución.

Existen múltiples operaciones intermedias, a continuación veremos las más frecuentes.

Operaciones de filtrado y mapeado

Además de las operaciones anteriores, existe un tipo de mapeado que devuelve múltiples resultados por cada valor procesado, este tipo de mapeado se denomina FlatMap. En la siguiente imagen se puede distinguir fácilmente la diferencia entre los Maps y los FlatMaps.

Un ejemplo práctico sería el siguiente, en el cual creamos un Stream a partir de un String, haciendo un split por la coma utilizando el método FlatMap.

Este método nos genera un nuevo Stream a partir de cada uno de los resultados obtenidos que podemos seguir procesando.

1
2
3
4
5
6
7

public static void main(String\[\] args) {

    Stream.of("Some, Comma, Separated, Values")
                .flatMap(string -> Stream.of(string.split(",")))
                .map(string -> string.trim())
                .forEach(System.out::println);
}

Operaciones de restricción de tamaño

Operaciones de ordenación y desordenación

Observando los elementos de un Stream

Operaciones terminales

Las operaciones terminales son las que terminan el pipeline de operaciones de un Stream y activan su ejecución. Un Stream solo se ejecutará cuando el pipeline incluya una de estas operaciones.

Al interpretar cómo se debe ejecutar la secuencia de operaciones del Stream, se aplican procesos de optimización para mergear o rechazar operaciones innecesarias, eliminar operaciones redundantes o ejecutar el stream en paralelo si fuera necesario.

Las operaciones terminales generan un valor o una acción como resultado, esto hace que este tipo de operaciones cierren la cadena de ejecución, ya que no devuelve un Stream.

Las operaciones terminales más comunes son las siguientes:

Operaciones condicionales

Operaciones que devuelve colecciones

Operaciones que devuelve resultados numéricos

Operaciones de iteración

Operaciones de reducción