Aplanamiento de colecciones anidadas en Java

Una secuencia es una secuencia de objetos que admite varios métodos que se pueden canalizar para producir el resultado deseado. Stream se utiliza para calcular elementos según los métodos canalizados sin alterar el valor original del objeto. Y aplanar significa fusionar dos o más colecciones en una sola. Considere la siguiente ilustración donde tenemos una array que incluye 3 arrays, pero después del efecto de aplanamiento, tendremos una array de resultados con todos los elementos en tres arrays.

Ilustración:

Input      : arr1[]  = {{1,2,3,4},{5,6,7},{8,9}}; 
Processing : Flattening
Output     : arr1[]  = {1,2,3,4,5,6,7,8,9};

El método Stream flatMap() se utiliza para aplanar un Stream de colecciones en un flujo de objetos. Los objetos se combinan de todas las colecciones en el flujo original. El método flatMap() es una transformación de uno a muchos de los elementos de la secuencia y luego aplana los elementos resultantes en una nueva secuencia. Básicamente , el método Stream.flatMap() ayuda a convertir Stream<Collection<T>> en Stream<T> .

Ejemplo 1: aplanar una secuencia de dos arrays del mismo tipo usando el método flatMap() 

// Java Program to Flatten a map containing a list of items
// as values using flatMap() method
 
// Importing input output classes
import java.io.*;
// Importing desired classes from java.util package
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
// Main class
public class GFG {
 
    // Method 1
    // To flatten a map containing a list of items as values
    public static <T> Stream<T>
    flatten(Collection<List<T> > values)
    {
 
        // Stream.flatMap() method converts
        // Stream<Collection<T>> to the  Stream<T>
        Stream<T> stream
            = values.stream().flatMap(x -> x.stream());
 
        // Return the desired stream
        return stream;
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of Map class
        // Declaring object of integer and string type
        Map<Integer, List<String> > map = new HashMap<>();
 
        // Adding elements to the above Map object
        // Custom input entries
        map.put(1, Arrays.asList("1", "2", "3"));
        map.put(2, Arrays.asList("4", "5", "6"));
 
        // Creating a List class object holding all elements
        // after flattening
        List<String> s = flatten(map.values())
                             .collect(Collectors.toList());
 
        // Print and display the above List object
        System.out.println(s);
    }
}

[A, B, C, i, J, K]

Ejemplo 2: aplanar una secuencia de dos listas del mismo tipo

// Java Program to flatten a stream of same type two arrays
// using flatMap() method
 
// Importing input output classes
import java.io.*;
// Importing Arrays and Stream classes
// from java.util package
import java.util.Arrays;
import java.util.stream.Stream;
 
// Main class
class GFG {
   
    // Method 1
    //  To flatten a stream of two arrays of the same type
    public static <T> Stream<T> flatten(T[] a, T[] b)
    {
        // Stream.flatMap() method converts
        // Stream<Collection<T>> to the  Stream<T>
        Stream<T> stream
            = Stream.of(a, b).flatMap(Arrays::stream);
 
        // Returns the desired stream
        return stream;
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
        // Input array of strings
 
        // Array 1 has uppercase characters
        String[] a = { "A", "B", "C" };
 
        // Array 2 has lowercase characters
        String[] b = { "i", "J", "K" };
          
        // Calling the above method in the main() method
        String[] s = flatten(a, b).toArray(String[] ::new);
 
        // Return string representation of contents
        // of integer array
        System.out.println(Arrays.toString(s));
    }
}

[Ma, Rs, Xy, Jw, Pi, Br]

Ejemplo 3: aplanar un mapa que contiene una lista de elementos como valores usando el método flatMap()

// Java Program to Flatten a map containing a list of items
// as values using flatMap() method
 
// Importing input output classes
import java.io.*;
// Importing desired classes from java.util package
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
// Main class
public class GFG {
 
    // Method 1
    // To flatten a map containing a list of items as values
    public static <T> Stream<T>
    flatten(Collection<List<T> > values)
    {
 
        // Stream.flatMap() method converts
        // Stream<Collection<T>> to the  Stream<T>
        Stream<T> stream
            = values.stream().flatMap(x -> x.stream());
 
        // Return the desired stream
        return stream;
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of Map class
        // Declaring object of integer and string type
        Map<Integer, List<String> > map = new HashMap<>();
 
        // Adding elements to the above Map object
        // Custom input entries
        map.put(1, Arrays.asList("1", "2", "3"));
        map.put(2, Arrays.asList("4", "5", "6"));
 
        // Creating a List class object holding all elements
        // after flattening
        List<String> s = flatten(map.values())
                             .collect(Collectors.toList());
 
        // Print and display the above List object
        System.out.println(s);
    }
}

[1, 2, 3, 4, 5, 6]