Stream flatMap() en Java con ejemplos

Stream flatMap(Mapeador de funciones) devuelve un flujo que consiste en los resultados de reemplazar cada elemento de este flujo con el contenido de un flujo mapeado producido al aplicar la función de mapeo provista a cada elemento. Stream flatMap (Mapeador de funciones) es una operación intermedia . Estas operaciones son siempre perezosas. Las operaciones intermedias se invocan en una instancia de Stream y, una vez que finalizan su procesamiento, dan una instancia de Stream como salida.

Nota: cada transmisión asignada se cierra después de que su contenido se haya colocado en esta transmisión. Si una secuencia asignada es nula, en su lugar se utiliza una secuencia vacía.

flatMap() V/s map() :
1) map() toma un Stream y lo transforma en otro Stream. Aplica una función en cada elemento de Stream y almacena el valor de retorno en el nuevo Stream. No aplana la corriente. Pero flatMap() es la combinación de un mapa y una operación plana, es decir, aplica una función a los elementos y los aplana.
2) map() se usa solo para la transformación, pero flatMap() se usa tanto para la transformación como para el aplanamiento.

Sintaxis:

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

where, R is the element type of the new stream.
Stream is an interface and T is the type 
of stream elements. mapper is a stateless function 
which is applied to each element and the function
returns the new stream.

Ejemplo 1: función flatMap() con función de mapeo provista.

// Java code for Stream flatMap
// (Function mapper) to get a stream by
// replacing the stream with a mapped
// stream by applying the provided mapping function.
import java.util.*;
import java.util.stream.Stream;
  
class GFG {
  
    // Driver code
    public static void main(String[] args)
    {
  
        // Creating a List of Strings
        List<String> list = Arrays.asList("5.6", "7.4", "4",
                                          "1", "2.3");
  
        // Using Stream flatMap(Function mapper)
        list.stream().flatMap(num -> Stream.of(num)).
                         forEach(System.out::println);
    }
}

Producción :

5.6
7.4
4
1
2.3

Ejemplo 2: función flatMap() con operación proporcionada de string de mapeo con carácter en la posición 2.

// Java code for Stream flatMap
// (Function mapper) to get a stream by
// replacing the stream with a mapped
// stream by applying the provided mapping function.
import java.util.*;
import java.util.stream.Stream;
  
class GFG {
  
    // Driver code
    public static void main(String[] args)
    {
  
        // Creating a List of Strings
        List<String> list = Arrays.asList("Geeks", "GFG",
                                 "GeeksforGeeks", "gfg");
  
        // Using Stream flatMap(Function mapper)
        list.stream().flatMap(str -> 
                         Stream.of(str.charAt(2))).
                         forEach(System.out::println);
    }
}

Producción :

e
G
e
g

¿Cómo funciona flatMap()?

Como ya se discutió en la publicación, flatMap() es la combinación de un mapa y una operación plana, es decir, primero aplica la función de mapa y luego aplana el resultado. Consideremos algunos ejemplos para entender qué es exactamente aplanar una corriente.
Ejemplo 1:
La lista antes de aplanar:

[ [2, 3, 5], [7, 11, 13], [17, 19, 23] ]

La lista tiene 2 niveles y consta de 3 listas pequeñas. Después de Flattening, se transforma en una estructura de «un nivel» como se muestra:

[ 2, 3, 5, 7, 11, 13, 17, 19, 23 ] 

Ejemplo 2:
La lista antes de aplanar:

[ ["G", "E", "E"], ["K", "S", "F"], ["O", "R", "G"], ["E", "E", "K", "S"] ]

La lista tiene 3 niveles y consta de 4 listas pequeñas. Después de Flattening, se transforma en una estructura de «un nivel» como se muestra:

["G", "E", "E", "K", "S", "F", "O", "R", "G", "E", "E", "K", "S"] 

En resumen, podemos decir que si hay un flujo de lista de << tipo de datos >> antes del aplanamiento, al aplicar flatMap(), se devuelve el flujo de << tipo de datos >> después del aplanamiento.
Solicitud :

// Java code for Stream flatMap(Function mapper) 
import java.util.*;
import java.util.stream.Collectors;
  
class GFG
{   
    // Driver code
    public static void main(String[] args)
    {   
        // Creating a list of Prime Numbers
        List<Integer> PrimeNumbers = Arrays.asList(5, 7, 11,13);
          
        // Creating a list of Odd Numbers
        List<Integer> OddNumbers = Arrays.asList(1, 3, 5);
          
        // Creating a list of Even Numbers
        List<Integer> EvenNumbers = Arrays.asList(2, 4, 6, 8);
  
        List<List<Integer>> listOfListofInts =
                Arrays.asList(PrimeNumbers, OddNumbers, EvenNumbers);
  
        System.out.println("The Structure before flattening is : " +
                                                  listOfListofInts);
          
        // Using flatMap for transformating and flattening.
        List<Integer> listofInts  = listOfListofInts.stream()
                                    .flatMap(list -> list.stream())
                                    .collect(Collectors.toList());
  
        System.out.println("The Structure after flattening is : " +
                                                         listofInts);
    }
}

Producción :

The Structure before flattening is : [[5, 7, 11, 13], [1, 3, 5], [2, 4, 6, 8]]
The Structure after flattening is : [5, 7, 11, 13, 1, 3, 5, 2, 4, 6, 8]