Java

Tutorial Java: Mapeo

Aprende a transformar y aplanar datos con Java Streams usando map() y flatMap() en programación funcional. Ejemplos claros y casos prácticos.

Aprende Java y certifícate

map()

El método map() es una de las operaciones más utilizadas en la programación funcional con Java Streams. Esta función permite transformar cada elemento de un Stream aplicando una función a cada uno de ellos, generando un nuevo Stream con los resultados de esas transformaciones.

La operación map() es una operación intermedia, lo que significa que devuelve un nuevo Stream que puede ser procesado posteriormente con otras operaciones. Su principal propósito es convertir o transformar los elementos sin cambiar la cantidad de elementos en el Stream.

Sintaxis básica

La firma del método map() es la siguiente:

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

Donde:

  • T es el tipo de los elementos en el Stream original
  • R es el tipo de los elementos en el Stream resultante
  • mapper es la función que se aplicará a cada elemento

Casos de uso comunes

  • 1. Transformación de tipos de datos:
List<String> nombres = List.of("Ana", "Juan", "Carlos");

// Convertir cada nombre a su longitud
List<Integer> longitudes = nombres.stream()
                                 .map(nombre -> nombre.length())
                                 .collect(Collectors.toList());

System.out.println(longitudes); // [3, 4, 6]
  • 2. Transformación de objetos:
class Producto {
    private String nombre;
    private double precio;
    
    // Constructor, getters y setters
    public Producto(String nombre, double precio) {
        this.nombre = nombre;
        this.precio = precio;
    }
    
    public String getNombre() { return nombre; }
    public double getPrecio() { return precio; }
}

List<Producto> productos = List.of(
    new Producto("Laptop", 1200.0),
    new Producto("Teléfono", 800.0),
    new Producto("Tablet", 500.0)
);

// Extraer solo los nombres de los productos
List<String> nombresProductos = productos.stream()
                                       .map(Producto::getNombre)
                                       .collect(Collectors.toList());

System.out.println(nombresProductos); // [Laptop, Teléfono, Tablet]
  • 3. Aplicar operaciones matemáticas:
List<Integer> numeros = List.of(1, 2, 3, 4, 5);

// Calcular el cuadrado de cada número
List<Integer> cuadrados = numeros.stream()
                               .map(n -> n * n)
                               .collect(Collectors.toList());

System.out.println(cuadrados); // [1, 4, 9, 16, 25]

Uso de referencias a métodos

Una forma más concisa de utilizar map() es mediante referencias a métodos, especialmente cuando la transformación consiste en llamar a un método existente:

List<String> palabras = List.of("hola", "mundo", "java");

// Convertir cada palabra a mayúsculas usando referencia a método
List<String> mayusculas = palabras.stream()
                                .map(String::toUpperCase)
                                .collect(Collectors.toList());

System.out.println(mayusculas); // [HOLA, MUNDO, JAVA]

Encadenamiento de operaciones map()

Es posible encadenar múltiples operaciones map() para realizar transformaciones secuenciales:

List<String> numTexto = List.of("1", "2", "3", "4");

// Convertir de String a Integer y luego calcular el doble
List<Integer> dobles = numTexto.stream()
                             .map(Integer::parseInt)  // String -> Integer
                             .map(n -> n * 2)         // Duplicar el valor
                             .collect(Collectors.toList());

System.out.println(dobles); // [2, 4, 6, 8]

Transformación de estructuras complejas

El método map() es especialmente útil cuando trabajamos con estructuras de datos complejas:

class Empleado {
    private String nombre;
    private List<String> habilidades;
    
    // Constructor, getters y setters
    public Empleado(String nombre, List<String> habilidades) {
        this.nombre = nombre;
        this.habilidades = habilidades;
    }
    
    public String getNombre() { return nombre; }
    public List<String> getHabilidades() { return habilidades; }
}

List<Empleado> empleados = List.of(
    new Empleado("Ana", List.of("Java", "SQL", "Spring")),
    new Empleado("Juan", List.of("Python", "JavaScript")),
    new Empleado("Carlos", List.of("C#", "Azure", ".NET"))
);

// Extraer solo las listas de habilidades de cada empleado
List<List<String>> todasLasHabilidades = empleados.stream()
                                                .map(Empleado::getHabilidades)
                                                .collect(Collectors.toList());

System.out.println(todasLasHabilidades);
// [[Java, SQL, Spring], [Python, JavaScript], [C#, Azure, .NET]]

Consideraciones importantes

  • Inmutabilidad: La operación map() no modifica el Stream original, sino que crea uno nuevo.
  • Evaluación perezosa: Como todas las operaciones intermedias en Streams, map() se evalúa de forma perezosa, lo que significa que no se ejecuta hasta que se invoca una operación terminal.
  • Función pura: La función que se pasa a map() debería ser una función pura (sin efectos secundarios) para mantener los principios de la programación funcional.

Ejemplo práctico: Procesamiento de datos JSON

Un caso de uso común es transformar datos JSON a objetos de dominio:

// Suponiendo que tenemos una lista de strings JSON
List<String> jsonData = obtenerDatosJSON();

// Transformar cada string JSON en un objeto Usuario
List<Usuario> usuarios = jsonData.stream()
                              .map(json -> convertirAUsuario(json))
                              .collect(Collectors.toList());

// Donde convertirAUsuario podría ser:
private Usuario convertirAUsuario(String json) {
    // Lógica para convertir JSON a Usuario
    // Usando bibliotecas como Jackson o Gson
    return new Usuario(/* datos extraídos del JSON */);
}

El método map() es una herramienta fundamental en la programación funcional con Java, permitiendo transformaciones de datos claras y concisas sin necesidad de bucles explícitos ni variables mutables.

flatMap()

El método flatMap() es una operación intermedia en la API de Streams de Java que permite trabajar con estructuras de datos anidadas o jerárquicas. A diferencia de map(), que transforma cada elemento en exactamente un elemento de salida, flatMap() puede generar múltiples elementos (o ninguno) por cada elemento de entrada.

La principal ventaja de flatMap() es su capacidad para aplanar colecciones anidadas, convirtiendo un Stream de colecciones en un único Stream de elementos individuales.

Sintaxis básica

La firma del método flatMap() es la siguiente:

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

Donde:

  • T es el tipo de los elementos en el Stream original
  • R es el tipo de los elementos en el Stream resultante
  • mapper es una función que convierte cada elemento en un Stream (que luego será aplanado)

Diferencia entre map() y flatMap()

La diferencia fundamental entre estos métodos se puede entender con un ejemplo simple:

// Usando map() con una lista de listas
List<List<Integer>> listaAnidada = List.of(
    List.of(1, 2), 
    List.of(3, 4), 
    List.of(5, 6)
);

// map() mantiene la estructura anidada
Stream<Stream<Integer>> streamDeStreams = listaAnidada.stream()
    .map(lista -> lista.stream());

// flatMap() aplana la estructura
Stream<Integer> streamAplanado = listaAnidada.stream()
    .flatMap(lista -> lista.stream());

// Recolectando resultados
List<Integer> numerosAplanados = streamAplanado.collect(Collectors.toList());
System.out.println(numerosAplanados); // [1, 2, 3, 4, 5, 6]

Casos de uso comunes

  • 1. Aplanar listas anidadas:
List<List<String>> listaDeListasDePalabras = List.of(
    List.of("Hola", "Mundo"),
    List.of("Java", "Streams"),
    List.of("Programación", "Funcional")
);

List<String> todasLasPalabras = listaDeListasDePalabras.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList());

System.out.println(todasLasPalabras); 
// [Hola, Mundo, Java, Streams, Programación, Funcional]
  • 2. Extraer elementos de objetos que contienen colecciones:
class Departamento {
    private String nombre;
    private List<Empleado> empleados;
    
    public Departamento(String nombre, List<Empleado> empleados) {
        this.nombre = nombre;
        this.empleados = empleados;
    }
    
    public String getNombre() { return nombre; }
    public List<Empleado> getEmpleados() { return empleados; }
}

class Empleado {
    private String nombre;
    
    public Empleado(String nombre) {
        this.nombre = nombre;
    }
    
    public String getNombre() { return nombre; }
}

// Lista de departamentos con sus empleados
List<Departamento> departamentos = List.of(
    new Departamento("Desarrollo", List.of(
        new Empleado("Ana"), 
        new Empleado("Carlos")
    )),
    new Departamento("Marketing", List.of(
        new Empleado("Luis"), 
        new Empleado("Elena")
    ))
);

// Obtener todos los empleados de todos los departamentos
List<Empleado> todosLosEmpleados = departamentos.stream()
    .flatMap(depto -> depto.getEmpleados().stream())
    .collect(Collectors.toList());

// Obtener solo los nombres de todos los empleados
List<String> nombresEmpleados = departamentos.stream()
    .flatMap(depto -> depto.getEmpleados().stream())
    .map(Empleado::getNombre)
    .collect(Collectors.toList());

System.out.println(nombresEmpleados); // [Ana, Carlos, Luis, Elena]
  • 3. Trabajar con Strings y caracteres:
List<String> palabras = List.of("Java", "Streams", "API");

// Obtener todos los caracteres individuales de todas las palabras
List<Character> caracteres = palabras.stream()
    .flatMap(palabra -> palabra.chars().mapToObj(c -> (char) c))
    .collect(Collectors.toList());

System.out.println(caracteres); 
// [J, a, v, a, S, t, r, e, a, m, s, A, P, I]
  • 4. Filtrar elementos nulos o vacíos:
List<String> textos = List.of("uno", null, "dos", "", "tres");

// Filtrar valores nulos o vacíos usando flatMap con Optional
List<String> textosFiltrados = textos.stream()
    .flatMap(texto -> Optional.ofNullable(texto)
                             .filter(t -> !t.isEmpty())
                             .stream())
    .collect(Collectors.toList());

System.out.println(textosFiltrados); // [uno, dos, tres]

Combinación con otras operaciones

flatMap() se puede combinar con otras operaciones de Stream para realizar transformaciones más complejas:

// Lista de frases
List<String> frases = List.of(
    "Java es genial",
    "Streams son útiles",
    "Programación funcional"
);

// Obtener palabras únicas ordenadas alfabéticamente
List<String> palabrasUnicas = frases.stream()
    .flatMap(frase -> Arrays.stream(frase.toLowerCase().split(" ")))
    .distinct()
    .sorted()
    .collect(Collectors.toList());

System.out.println(palabrasUnicas); 
// [es, funcional, genial, java, programación, son, streams, útiles]

Uso con Optional para evitar valores nulos

flatMap() es especialmente útil cuando se trabaja con la clase Optional para manejar valores potencialmente nulos:

// Método que puede devolver un valor nulo
public Optional<Usuario> buscarUsuario(String id) {
    // Lógica para buscar usuario
    return Optional.ofNullable(/* resultado que puede ser null */);
}

// Método que obtiene direcciones de un usuario
public List<Direccion> obtenerDirecciones(Usuario usuario) {
    return /* lista de direcciones */;
}

// Uso de flatMap con Optional
String userId = "12345";
List<Direccion> direcciones = Optional.ofNullable(userId)
    .flatMap(this::buscarUsuario)
    .map(this::obtenerDirecciones)
    .orElse(Collections.emptyList());

Ejemplo práctico: Procesamiento de datos JSON anidados

Un caso de uso real es procesar estructuras JSON anidadas:

class Pedido {
    private String id;
    private List<LineaPedido> lineas;
    
    // Constructor, getters y setters
    public Pedido(String id, List<LineaPedido> lineas) {
        this.id = id;
        this.lineas = lineas;
    }
    
    public String getId() { return id; }
    public List<LineaPedido> getLineas() { return lineas; }
}

class LineaPedido {
    private String producto;
    private int cantidad;
    
    // Constructor, getters y setters
    public LineaPedido(String producto, int cantidad) {
        this.producto = producto;
        this.cantidad = cantidad;
    }
    
    public String getProducto() { return producto; }
    public int getCantidad() { return cantidad; }
}

// Lista de pedidos
List<Pedido> pedidos = List.of(
    new Pedido("P001", List.of(
        new LineaPedido("Laptop", 1),
        new LineaPedido("Mouse", 2)
    )),
    new Pedido("P002", List.of(
        new LineaPedido("Monitor", 1),
        new LineaPedido("Teclado", 1)
    ))
);

// Obtener todos los productos de todos los pedidos
List<String> todosLosProductos = pedidos.stream()
    .flatMap(pedido -> pedido.getLineas().stream())
    .map(LineaPedido::getProducto)
    .collect(Collectors.toList());

System.out.println(todosLosProductos); // [Laptop, Mouse, Monitor, Teclado]

Consideraciones de rendimiento

  • Evaluación perezosa: Al igual que map(), flatMap() se evalúa de forma perezosa.
  • Consumo de memoria: Cuando se trabaja con grandes colecciones anidadas, flatMap() puede ser más eficiente que extraer manualmente cada elemento con bucles anidados.
  • Paralelismo: flatMap() es compatible con streams paralelos, lo que puede mejorar el rendimiento en colecciones grandes.
// Versión paralela para colecciones grandes
List<String> resultadoParalelo = listaGrande.parallelStream()
    .flatMap(elemento -> procesarElemento(elemento).stream())
    .collect(Collectors.toList());

El método flatMap() es una herramienta esencial cuando necesitamos trabajar con estructuras de datos anidadas o cuando queremos transformar cada elemento de entrada en múltiples elementos de salida, simplificando considerablemente el código y haciéndolo más legible y mantenible.

CONSTRUYE TU CARRERA EN IA Y PROGRAMACIÓN SOFTWARE

Accede a +1000 lecciones y cursos con certificado. Mejora tu portfolio con certificados de superación para tu CV.

30 % DE DESCUENTO

Plan mensual

19.00 /mes

13.30 € /mes

Precio normal mensual: 19 €
63 % DE DESCUENTO

Plan anual

10.00 /mes

7.00 € /mes

Ahorras 144 € al año
Precio normal anual: 120 €
Aprende Java online

Ejercicios de esta lección Mapeo

Evalúa tus conocimientos de esta lección Mapeo con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.

Streams: match

Test

Gestión de errores y excepciones

Código

CRUD en Java de modelo Customer sobre un ArrayList

Proyecto

Clases abstractas

Test

Listas

Código

Métodos de la clase String

Código

Streams: reduce()

Test

API java.nio 2

Puzzle

Polimorfismo

Código

Pattern Matching

Código

Streams: flatMap()

Test

Llamada y sobrecarga de funciones

Puzzle

Métodos referenciados

Test

Métodos de la clase String

Código

Representación de Fecha

Puzzle

Operadores lógicos

Test

Inferencia de tipos con var

Código

Tipos de datos

Código

Estructuras de iteración

Puzzle

Streams: forEach()

Test

Objetos

Puzzle

Funciones lambda

Test

Uso de Scanner

Puzzle

Tipos de variables

Puzzle

Streams: collect()

Puzzle

Operadores aritméticos

Puzzle

Arrays y matrices

Código

Clases y objetos

Código

Interfaz funcional Consumer

Test

CRUD en Java de modelo Customer sobre un HashMap

Proyecto

Interfaces

Código

Enumeraciones Enums

Código

API Optional

Test

Interfaz funcional Function

Test

Encapsulación

Test

Interfaces

Código

Uso de API Optional

Puzzle

Representación de Hora

Test

Herencia básica

Test

Clases y objetos

Código

Interfaz funcional Supplier

Puzzle

HashMap

Puzzle

Sobrecarga de métodos

Test

Polimorfismo de tiempo de ejecución

Puzzle

OOP en Java

Proyecto

Sobrecarga de métodos

Código

CRUD de productos en Java

Proyecto

Clases sealed

Código

Creación de Streams

Test

Records

Código

Encapsulación

Código

Streams: min max

Puzzle

Herencia

Código

Métodos avanzados de la clase String

Puzzle

Funciones

Código

Polimorfismo de tiempo de compilación

Test

Reto sintaxis Java

Proyecto

Conjuntos

Código

Estructuras de control

Código

Recursión

Código

Excepciones

Puzzle

Herencia avanzada

Puzzle

Estructuras de selección

Test

Uso de interfaces

Test

Operadores

Código

Variables

Código

HashSet

Test

Objeto Scanner

Test

Streams: filter()

Puzzle

Operaciones de Streams

Puzzle

Interfaz funcional Predicate

Puzzle

Streams: sorted()

Test

Configuración de entorno

Test

Uso de variables

Test

Clases

Test

Streams: distinct()

Puzzle

Streams: count()

Test

ArrayList

Test

Mapas

Código

Datos de referencia

Test

Interfaces funcionales

Puzzle

Métodos básicos de la clase String

Test

Tipos de datos

Código

Clases abstractas

Código

Instalación

Test

Funciones

Código

Excepciones

Código

Estructuras de control

Código

Herencia de clases

Código

La clase Scanner

Código

Generics

Código

Streams: map()

Puzzle

Funciones y encapsulamiento

Test

Todas las lecciones de Java

Accede a todas las lecciones de Java y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.

Instalación De Java

Introducción Y Entorno

Configuración De Entorno Java

Introducción Y Entorno

Tipos De Datos

Sintaxis

Variables

Sintaxis

Operadores

Sintaxis

Estructuras De Control

Sintaxis

Funciones

Sintaxis

Recursión

Sintaxis

Arrays Y Matrices

Sintaxis

Excepciones

Programación Orientada A Objetos

Clases Y Objetos

Programación Orientada A Objetos

Encapsulación

Programación Orientada A Objetos

Herencia

Programación Orientada A Objetos

Clases Abstractas

Programación Orientada A Objetos

Interfaces

Programación Orientada A Objetos

Sobrecarga De Métodos

Programación Orientada A Objetos

Polimorfismo

Programación Orientada A Objetos

La Clase Scanner

Programación Orientada A Objetos

Métodos De La Clase String

Programación Orientada A Objetos

Excepciones

Programación Orientada A Objetos

Records

Programación Orientada A Objetos

Pattern Matching

Programación Orientada A Objetos

Inferencia De Tipos Con Var

Programación Orientada A Objetos

Enumeraciones Enums

Programación Orientada A Objetos

Generics

Programación Orientada A Objetos

Clases Sealed

Programación Orientada A Objetos

Listas

Framework Collections

Conjuntos

Framework Collections

Mapas

Framework Collections

Funciones Lambda

Programación Funcional

Interfaz Funcional Consumer

Programación Funcional

Interfaz Funcional Predicate

Programación Funcional

Interfaz Funcional Supplier

Programación Funcional

Interfaz Funcional Function

Programación Funcional

Métodos Referenciados

Programación Funcional

Creación De Streams

Programación Funcional

Operaciones Intermedias Con Streams: Map()

Programación Funcional

Operaciones Intermedias Con Streams: Filter()

Programación Funcional

Operaciones Intermedias Con Streams: Distinct()

Programación Funcional

Operaciones Finales Con Streams: Collect()

Programación Funcional

Operaciones Finales Con Streams: Min Max

Programación Funcional

Operaciones Intermedias Con Streams: Flatmap()

Programación Funcional

Operaciones Intermedias Con Streams: Sorted()

Programación Funcional

Operaciones Finales Con Streams: Reduce()

Programación Funcional

Operaciones Finales Con Streams: Foreach()

Programación Funcional

Operaciones Finales Con Streams: Count()

Programación Funcional

Operaciones Finales Con Streams: Match

Programación Funcional

Api Optional

Programación Funcional

Transformación

Programación Funcional

Reducción Y Acumulación

Programación Funcional

Mapeo

Programación Funcional

Streams Paralelos

Programación Funcional

Agrupación Y Partición

Programación Funcional

Filtrado Y Búsqueda

Programación Funcional

Api Java.nio 2

Entrada Y Salida Io

Fundamentos De Io

Entrada Y Salida Io

Leer Y Escribir Archivos

Entrada Y Salida Io

Httpclient Moderno

Entrada Y Salida Io

Clases De Nio2

Entrada Y Salida Io

Api Java.time

Api Java.time

Localtime

Api Java.time

Localdatetime

Api Java.time

Localdate

Api Java.time

Executorservice

Concurrencia

Virtual Threads (Project Loom)

Concurrencia

Future Y Completablefuture

Concurrencia

Spring Framework

Frameworks Para Java

Micronaut

Frameworks Para Java

Maven

Frameworks Para Java

Gradle

Frameworks Para Java

Lombok Para Java

Frameworks Para Java

Quarkus

Frameworks Para Java

Ecosistema Jakarta Ee De Java

Frameworks Para Java

Introducción A Junit 5

Testing

Accede GRATIS a Java y certifícate

Certificados de superación de Java

Supera todos los ejercicios de programación del curso de Java y obtén certificados de superación para mejorar tu currículum y tu empleabilidad.

En esta lección

Objetivos de aprendizaje de esta lección

  • Comprender el funcionamiento y la sintaxis del método map() en Java Streams.
  • Aprender a transformar elementos de un Stream utilizando funciones y referencias a métodos.
  • Diferenciar entre map() y flatMap() y entender cuándo usar cada uno.
  • Aplicar flatMap() para aplanar colecciones anidadas y trabajar con estructuras complejas.
  • Conocer casos prácticos y consideraciones de rendimiento y evaluación perezosa en Streams.