El método map() forma parte del API de Streams en Java (desde Java 8). Se utiliza para transformar cada elemento de un Stream en otro valor, aplicando una función de mapeo. Es una de las operaciones intermedias más importantes en programación funcional en Java.
1. ¿Qué es map()?
Definición de la firma:
<R> Stream<R> map(Function<? super T, ? extends R> mapper)
- T → tipo de dato original.
- R → tipo de dato resultante.
- Recibe una Function para transformar.
- Devuelve un nuevo Stream con los datos transformados.
2. Uso básico de map()
List<String> nombres =
Arrays.asList("ana", "pedro", "luis");
nombres.stream()
.map(nombre ->
nombre.toUpperCase())
.forEach(System.out::println);
// SALIDA:
// ANA
// PEDRO
// LUIS
3. Ejemplos prácticos
3.1. Convertir Strings a enteros
List<String> numeros =
Arrays.asList("1", "2", "3");
List<Integer> listaEnteros = numeros.stream()
.map(n -> Integer.parseInt(n))
.toList();
System.out.println(listaEnteros); // [1, 2, 3]
3.2. Calcular longitudes de cadenas
List<String> palabras =
Arrays.asList("java", "lambda", "stream");
List<Integer> longitudes = palabras.stream()
.map(p
-> p.length())
.toList();
System.out.println(longitudes); // [4, 6, 6]
3.3. Transformar objetos (Mapeo de atributos)
class Persona {
String nombre;
int edad;
Persona(String n, int e) { nombre =
n; edad = e; }
}
List<Persona> personas = Arrays.asList(
new Persona("Ana", 20),
new Persona("Luis", 30)
);
List<String> nombres = personas.stream()
.map(p
-> p.nombre)
.toList();
System.out.println(nombres); // [Ana, Luis]
3.4. Encadenar map() con otras operaciones
List<String> lista =
Arrays.asList("java", "lambda", "stream");
lista.stream()
.map(s -> s.toUpperCase())
.map(s -> s + "!!")
.forEach(System.out::println);
// SALIDA:
// JAVA!!
// LAMBDA!!
// STREAM!!
4. Diferencia entre map() y flatMap()
- map(): un elemento de entrada se
transforma en un solo elemento de salida.
- flatMap(): un elemento de entrada puede transformarse en 0, 1 o muchos
elementos.
List<List<Integer>> listaDeListas
= Arrays.asList(
Arrays.asList(1, 2),
Arrays.asList(3, 4)
);
// Con map → Stream<List<Integer>>
System.out.println(listaDeListas.stream()
.map(l
-> l.stream())
.toList());
// Con flatMap → Stream<Integer>
System.out.println(listaDeListas.stream()
.flatMap(l -> l.stream())
.toList()); // [1, 2, 3, 4]
5. Casos de uso comunes de map()
🔄 Transformar tipos de datos (String → Integer).
🔠 Convertir texto a mayúsculas o minúsculas.
🧾 Extraer atributos de objetos (ej: nombres de personas).
📊 Procesar datos para cálculos (ej: obtener longitudes, precios con descuento).
🔗 Encadenar transformaciones en un Stream.
Conclusión
El método map() es fundamental en la programación funcional con Java. Permite transformar datos de forma elegante, encadenar operaciones y trabajar con colecciones de manera más declarativa.
