Mapeo de Resultados - Tensho97/Aprende-a-Aprender GitHub Wiki

Una vez hemos realizado la selección (filtro), podemos transformar los elementos de un Stream al extraer información de éstos. Para lograrlo usamos alguno de los siguientes métodos:

+map(Function<T, R>): Stream

Retorna un Stream que contiene el resultado de aplicar la función pasada por parámetro a todos los elementos del Stream. Transforma los elementos del tipo T al tipo R.

El siguiente ejemplo muestra cómo transformar un Stream de cadenas a otro Stream de esas mismas cadenas pero en mayúsculas. La función usada en este caso es una función (expresión lambda) dónde T y R son de tipo java.lang.String:

List<.String>  paises = Arrays.asList("Colombia", "Perú",  "Panamá"); 
//Stream cuyos elementos son los países en mayúsculas 
Stream<String>  stream = paises
            .stream()
            .map(String::toUpperCase);

El anterior método también existe en sus versiones “primitivas”:

* +mapToDouble(ToDoubleFunction<T>): DoubleStream
* +mapToInt(ToIntFunction<T>): IntStream
* +mapToLong(ToLongFunction<T>): LongStream

Como pudimos observar en el apartado de propiedades y caracteristicas de un Stream, La ventaja de usar las versiones primitivas radica en que se evita el uso de Autoboxing y Unboxing, lo que en algunas situaciones puede ser deseado por temas de rendimiento.

+flatMap(Function<T, Stream):Stream

Permite transformar cada elemento del Stream en otro Stream y al final concatenarlos todos en uno solo. Es un poco confuso, pero pensemos que cuando tengamos un Stream<Stream>, este método nos permitirá transformarlo en Stream.

En el siguiente ejemplo, vamos a crear un Stream de las distintas palabras de una lista de cadenas:

List<String> lista = Arrays.asList("Taller", "Taller Lambdas y API  Stream"); 
Stream stream = lista.stream() 
               .map(s ->  s.split(" ")) // Stream<String[]> 
               .map(Arrays::stream) //  Stream<Stream<String>> 
               .flatMap(Function.identity()) // Stream<String> 
               .distinct(); //  Stream<String> de 5 elementos 

Nótese que primero obtuvimos las palabras de cada cadena, esa operación nos deja con un Stream de arreglos de cadenas. Luego invocamos el método estático +Arrays.stream(T[]):Stream el cual nos deja con un Stream de Stream de cadenas. Es en ese momento donde flatMap es de gran utilidad, ya que nos permite concatenar todos esos Streams en uno solo.

Para efectos de claridad, el ejemplo anterior primero obtiene un Stream<Stream> y luego usa flatmap para quedar solo con Stream.

Una versión más directa del ejemplo anterior se puede escribir como sigue a continuación:

List<String>  lista = Arrays.asList("Taller", "Taller Lambdas y API  Stream"); 
Stream stream = lista.stream() 
              .map(s -> s.split(" ")) //  Stream<String[]> 
              .flatMap(Arrays::stream)  // Stream<String> 
              .distinct(); //  Stream<String> de 5 elementos 

El método .flatMap también existe en sus versiones “primitivas”:

+flatMapToDouble(Function<T, DoubleStream): DoubleStream
+flatMapToInt(Function<T, IntStream): IntStream
+flatMapToLong(Function<T, LongStream): LongStream

El último paso son las operaciones terminales.

Autor: Richard