La API Stream de Java

Imagina que tenemos una clase Alumno que tiene los atributos:

• dni
• nombre
• edad
• curso

con los correspondientes getters y el constructor.

Además, tenemos definida una lista de objetos Alumno y nos queda implementar un fragmento de código en Java que muestre al alumnado ordenado de mayor a menor edad.

Solución tradicional:

listaAlumnado.sort(new Comparator<Alumno>() {
        @Override
        public int compare(Alumno a1, Alumno a2) {
            return a2.getEdad() - a1.getEdad();
        }
    }
});

Solución con expresiones Lambda:

listaAlumnado.sort((a1, a2) -> a2.getEdad() - a1.getEdad());

Siguiendo con la clase Alumno anterior, imagina que deseamos crear un método que devuelva el alumnado matriculado a un curso determinado.

Solución imperativa:

public List<Alumno> filtrarAlumnado(List<Alumno> listaAlumnado, String curso) {
    List<Alumno> listaFiltrada = new LinkedList<>();
    for (Alumno alu : listaAlumnado) {
        if (alu.getCurso().equals(curso)) {
            listaFiltrada.add(alu);
        }
    }

    return listaFiltrada;
}

Solución declarativa con expresiones Lambda:

public List<Alumno> filtrarAlumnado(List<Alumno> listaAlumnado, String curso) {
    return listaAlumnado.stream()
        .filter(alu -> alu.getCurso().equals(curso))
        .collect(Collectors.toList());
}

El operador filter permite quedarnos con los datos de una colección que cumplan el criterio indicado como parámetro.

En este ejemplo se obtiene como resultado un Stream, es decir, el resultado intermedio de una operación:

Stream<Alumno> filtro = listaAlumnado.stream()
    .filter(alu -> alu.getApellidos().charAt(0) == 'L' || c.getApellidos().charAt(0) == 'G');

El operador filter recibe un predicado (Predicate<? super T>) en forma, normalmente, de Lambda aunque también puede ser la referencia a un método. El resultado del predicado es un valor booleano, true o false, para poder decidir qué elementos se queda y qué elementos descarta.

El operador map permite transformar la colección original ya sea para quedarnos con cierta parte de la información o crear otros datos.

En este ejemplo, a partir del listado de alumnado obtenemos un un Stream solo con los nombres del alumnado:

Stream<String> nombres = listaAlumnado.stream()
    .map(Alumno::getNombre);

El operador map recibe una función como argumento que recibe un objeto del tipo original y devuelva el tipo resultante, haciendo así la transformación elemento a elemento.

Se pueden combinar operaciones intermedias, como en el ejemplo de abajo donde obtenemos el nombre (map) del alumnado mayor de edado (filter):

Stream<String> nombres = listaAlumnado.stream()
    .filter(alu -> alu.getEdad() >= 18)
    .map(Alumno::getNombre);

El operador sorted permite ordenar los elementos del Stream. Puede utilizarse de dos formas: sin parámetros (si los objetos implementan la interfaz Comparable) o pasándole un Comparator personalizado (habitualmente mediante una expresión Lambda o un método de referencia).

En este ejemplo, ordenamos el alumnado de menor a mayor edad y obtenemos un Stream resultante con dicho orden:

Stream<Alumno> ordenadosPorEdad = listaAlumnado.stream()
    .sorted((a1, a2) -> Integer.compare(a1.getEdad(), a2.getEdad()));

También podemos combinarlo con referencias a métodos para mayor claridad:

Stream<Alumno> ordenadosPorEdad = listaAlumnado.stream()
    .sorted(Comparator.comparingInt(Alumno::getEdad));

El operador flatMap se utiliza cuando cada elemento del Stream contiene a su vez otra colección o estructura de datos (por ejemplo, si cada Alumno tiene una lista de asignaturas o notas: List<String> asignaturas).

A diferencia de map (que devolvería un Stream<List<String>>), flatMap "aplana" todos esos flujos o listas individuales en un único flujo unidimensional de elementos (Stream<String>).

Imagina que la clase Alumno dispone del método getAsignaturas() que devuelve List<String>. Si queremos obtener un único Stream con todas las asignaturas cursadas por el alumnado (sin listas anidadas):

Stream<String> todasLasAsignaturas = listaAlumnado.stream()
    .flatMap(alu -> alu.getAsignaturas().stream());

Aunque habitualmente los Stream se crean a partir de una colección existente (mediante lista.stream()), la clase Stream proporciona el método estático of para crear un flujo de datos directamente a partir de valores sueltos o un array.

Stream<String> cursos = Stream.of("1º DAM", "2º DAM", "1º DAW", "2º DAW");

A diferencia de las anteriores, anyMatch es una operación terminal o final (cierra el Stream y devuelve un valor de tipo boolean). Su objetivo es comprobar si al menos un elemento de la colección cumple con la condición indicada.

Recibe como argumento un predicado (Predicate<? super T>) y realiza una evaluación cortocircuitada (en cuanto encuentra el primer elemento que cumple la condición, deja de procesar el resto de la lista):

En este ejemplo, comprobamos si existe algún alumno menor de edad en la lista:

boolean hayMenores = listaAlumnado.stream()
    .anyMatch(alu -> alu.getEdad() < 18);

El operador collect permite obtener algún tipo de colección a partir de los datos procesados por las operaciones intermedia dando por cerrado el Stream.

Por ejemplo: obtener la lista de los DNI del alumnado que cursa el curso "DAM":

List<String> dnis = listaAlumnado.stream()
    .filter(a -> a.getCurso.equals("DAM"))
    .map(Alumno::getDni)
    .collect(Collectors.toList());

En este otro ejemplo usamos Collectors.joining para crear un String donde se listan todos los DNI de los que cursan "DAM" con el prefijo "Todos los DNI: ", con el separador com (,) y como sufijo el punto final (.):

String dnisConcatenados = listaAlumnado.stream()
    .filter(a -> a.getCurso.equals("DAM"))
    .map(Alumno::getDni)
    .collect(Collectors.joining(",", "Todos los DNI: ", "."));

El operador forEach permite recorrer cada elemento del Stream resultante y hacrer con él lo que sea necesario. Recibe un consumidor (Consumer<? super T>) que no devuelve ningún valor.

Por ejemplo, mostrar por pantalla, en líneas separadas, los nombres del alumnado mayor de edad:

listaAlumnado.stream()
    .filter(alu -> alu.getEdad() >= 18)
    .forEach(alu -> System.out.println(alu.getNombre() + " es mayor de edad."));

O, simplificando el ejemplo anterior, combinando filter con map conseguimos un forEach "más limpio":

listaAlumnado.stream()
    .filter(a -> a.getEdad >= 18)
    .map(Alumno::getNombre)
    .forEach(System.out::println);

Para realizar cálculos estadísticos o de búsqueda sobre valores numéricos, los Stream disponen de operadores dedicados.

Es una de las operaciones de recolección más potentes de la API. Se pasa como argumento a la operación terminal collect y permite agrupar los elementos del Stream según un criterio específico (clasificador), devolviendo un objeto de tipo Map<K, List<V>>.

En este ejemplo agrupamos a los alumnos según el curso en el que están matriculados:

Map<String, List<Alumno>> alumnadoPorCurso = listaAlumnado.stream()
    .collect(Collectors.groupingBy(Alumno::getCurso));