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ícatemap()
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.
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
Gestión de errores y excepciones
CRUD en Java de modelo Customer sobre un ArrayList
Clases abstractas
Listas
Métodos de la clase String
Streams: reduce()
API java.nio 2
Polimorfismo
Pattern Matching
Streams: flatMap()
Llamada y sobrecarga de funciones
Métodos referenciados
Métodos de la clase String
Representación de Fecha
Operadores lógicos
Inferencia de tipos con var
Tipos de datos
Estructuras de iteración
Streams: forEach()
Objetos
Funciones lambda
Uso de Scanner
Tipos de variables
Streams: collect()
Operadores aritméticos
Arrays y matrices
Clases y objetos
Interfaz funcional Consumer
CRUD en Java de modelo Customer sobre un HashMap
Interfaces
Enumeraciones Enums
API Optional
Interfaz funcional Function
Encapsulación
Interfaces
Uso de API Optional
Representación de Hora
Herencia básica
Clases y objetos
Interfaz funcional Supplier
HashMap
Sobrecarga de métodos
Polimorfismo de tiempo de ejecución
OOP en Java
Sobrecarga de métodos
CRUD de productos en Java
Clases sealed
Creación de Streams
Records
Encapsulación
Streams: min max
Herencia
Métodos avanzados de la clase String
Funciones
Polimorfismo de tiempo de compilación
Reto sintaxis Java
Conjuntos
Estructuras de control
Recursión
Excepciones
Herencia avanzada
Estructuras de selección
Uso de interfaces
Operadores
Variables
HashSet
Objeto Scanner
Streams: filter()
Operaciones de Streams
Interfaz funcional Predicate
Streams: sorted()
Configuración de entorno
Uso de variables
Clases
Streams: distinct()
Streams: count()
ArrayList
Mapas
Datos de referencia
Interfaces funcionales
Métodos básicos de la clase String
Tipos de datos
Clases abstractas
Instalación
Funciones
Excepciones
Estructuras de control
Herencia de clases
La clase Scanner
Generics
Streams: map()
Funciones y encapsulamiento
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
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.