Aprende a usar el método flatmap en Java: una guía corta

El método flatMap en Java es una de las funciones más útiles de la programación funcional. Fue implementada en Java 8 con los Streams y sus versiones posteriores. Hoy queremos explicarte un poco en qué consiste flatMap en Java, sus diferencias con el método map y algunos ejemplos que te harán entender mejor el concepto.

¿Qué es flatMap en Java?

Flatmap en Java es un método que se usa para aplanar estructuras de datos anidados y convertirlas en una sola secuencia. En otras palabras, lo que hace flatMap en Java es convertir estructuras complicadas de datos, como listas dentro de listas, y pasarlas a una sola lista. A este proceso se le conoce como aplanar. Por ejemplo, si tienes varias listas pequeñas dentro de una lista grande, flatMap las junta todas en una sola lista para que sea mucho más simple trabajar con esos datos dentro. Así, lo que sucede es que, en vez de manejar varias listas, te quedas con una única secuencia de elementos que puedes procesar de manera distinta.

¿Cuál es la diferencia entre map y flatMap?

Ambos métodos son similares, pero tienen una gran diferencia, a saber:

• map() transforma cada elemento de un stream en otro valor, manteniendo la estructura original del stream. Si tienes un stream de listas, seguirá siendo un stream de listas.
• flatMap(), por otro lado, aplanará o “descomprimirá” esos streams anidados, creando un único stream con todos los elementos, sin mantener las estructuras internas.

//Ejemplo usando map
List<List<Integer>> numeros = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4)
);

List<List<Integer>> resultado = numeros.stream()
    .map(lista -> lista.stream().map(n -> n * 2).toList())
    .toList();

// El resultado es una lista de listas
// [[2, 4], [6, 8]]

Aquí, el método map() mantiene la estructura de listas dentro de listas, ya que solo transforma cada número dentro de su lista original.

//Ejemplo usando flatMap
List<List<Integer>> numeros = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4)
);

List<Integer> resultado = numeros.stream()
    .flatMap(lista -> lista.stream().map(n -> n * 2))
    .toList();

// El resultado es una lista simple de números
// [2, 4, 6, 8]

En este caso, flatMap en Java aplana las listas y devuelve un único stream con todos los números.

¿Cómo usar flatMap en Java?: un ejemplo

Entender el uso de flatMap por medio de un ejemplo será mucho más simple. Supongamos que tienes una clase Persona que contiene una lista de Viajes. Tu objetivo es conocer todos los países visitados por las personas. Veamos:

import java.util.List;
import java.util.ArrayList;

public class Persona {
    private String nombre;
    private List<Viaje> listaViajes;

    public Persona(String nombre) {
        this.nombre = nombre;
        this.listaViajes = new ArrayList<>();
    }

    public void addViaje(Viaje viaje) {
        listaViajes.add(viaje);
    }

    public List<Viaje> getListaViajes() {
        return listaViajes;
    }
}

class Viaje {
    private String pais;

    public Viaje(String pais) {
        this.pais = pais;
    }

    public String getPais() {
        return pais;
    }
}

En este caso, una Persona tiene una lista de viajes. Lo que queremos hacer es obtener todos los países que han visitado varias personas. Aquí es donde el método flatMap en Java nos servirá.

Ahora supongamos que tenemos dos personas, Pedro y Gema, y cada una ha realizado algunos viajes. Queremos obtener una lista con todos los países que han visitado. El código quedaría así:

import java.util.Arrays;
import java.util.List;

public class EjemploFlatMap {
    public static void main(String[] args) {
        Persona pedro = new Persona("Pedro");
        pedro.addViaje(new Viaje("Francia"));
        pedro.addViaje(new Viaje("Inglaterra"));

        Persona gema = new Persona("Gema");
        gema.addViaje(new Viaje("Italia"));
        gema.addViaje(new Viaje("Bélgica"));

        List<Persona> personas = Arrays.asList(pedro, gema);

        // Usamos flatMap para obtener todos los países visitados
        List<String> paises = personas.stream()
            .flatMap(persona -> persona.getListaViajes().stream())
            .map(viaje -> viaje.getPais())
            .toList();

        paises.forEach(System.out::println); // Imprime todos los países
    }
}

En este código:

1. Usamos el método flatMap para convertir cada lista de viajes (una por persona) en un solo stream de viajes.
2. Luego, usamos map() para obtener el nombre del país de cada viaje.
3. Finalmente, recolectamos los países en una lista y los imprimimos.

El resultado final sería:

//Nombres de los países que visitaron Pedro y Gema
Francia
Inglaterra
Italia
Bélgica

Si te interesa la programación y el lenguaje Java, no te pierdas nuestro curso java en Keepcoding, un bootcamp formativo en el que podrás prepararte para la vida laboral. ¡No dejes pasar esta gran oportunidad de seguir aprendiendo y únete ya!