Streams y lambdas en Java: filtra y transforma listas sin escribir bucles

Sigue al post de excepciones: cómo consultar una lista de pedidos sin un for lleno de if

Te piden el total con IVA de los pedidos de Madrid que pasan de 50 €. Escribes un for, metes un if con dos condiciones, declaras una variable fuera para ir sumando y funciona. Dos días después te piden añadir otro filtro y además agrupar por ciudad, y el bucle empieza a parecer un cajón de sastre. Aquí es donde la mayoría se atasca con las colecciones: saben recorrerlas, pero no saben consultarlas con comodidad.

Si alguna vez has filtrado una tabla de Excel por ciudad y la has ordenado por importe, ya sabes lo que vamos a hacer: decirle a Java qué quieres sacar de la lista, no cómo recorrerla fila a fila. Este post sigue al de ArrayList y HashMap y usa lo que viste en el de excepciones para entender un par de errores que te van a salir sí o sí.

Todo el código está probado con JDK 21 y funciona igual en Java 17 y en Java 25 (la última versión LTS). Necesitas Java 16 o superior, porque usamos record y toList(), que llegaron en esa versión.

El bucle que crece sin control

Este es el punto de partida. Una lista de pedidos de una tienda online y el cálculo de antes: el total con IVA del 21% de los pedidos de Madrid que superan los 50 €.

Java: Informe.java 📋
import java.util.List;

public class Informe {
    record Pedido(String cliente, String ciudad, double importe, String estado) {}

    public static void main(String[] args) {
        List<Pedido> pedidos = List.of(
            new Pedido("Lucía", "Madrid", 89.90, "ENTREGADO"),
            new Pedido("Pablo", "Valencia", 35.00, "ENTREGADO"),
            new Pedido("Marta", "Madrid", 120.50, "PENDIENTE"),
            new Pedido("Iván", "Sevilla", 64.20, "ENTREGADO"),
            new Pedido("Carmen", "Valencia", 210.00, "ENTREGADO"),
            new Pedido("Raúl", "Madrid", 18.75, "CANCELADO")
        );

        double total = 0;
        for (Pedido p : pedidos) {
            if (p.ciudad().equals("Madrid") && p.importe() > 50) {
                total += p.importe() * 1.21;
            }
        }
        System.out.printf("Total Madrid con IVA: %.2f €%n", total);
    }
}

Dos cosas antes de seguir. Pedido es un record, una forma corta de declarar una clase que solo guarda datos: Java te genera el constructor y los métodos para leer cada campo (p.ciudad(), p.importe()), sin que escribas getters. Y la salida lleva coma porque mi Java está configurado en español de España; si el tuyo está en inglés verás 254.58.

Salida en consola 📋
Total Madrid con IVA: 254,58 €

⚠️ Importante: dinero y double

Para aprender Streams uso double porque el ejemplo es más corto. En una factura de verdad usa BigDecimal, como vimos en el post de excepciones, para que los redondeos no te den un disgusto.

El código funciona. El problema es que el qué (pedidos de Madrid de más de 50 €) está mezclado con el cómo (recorrer, comprobar, acumular en una variable). Con tres condiciones más y un agrupado, ese bucle ya no se lee de un vistazo.

Lambdas: una función sin nombre

En una web, cuando quieres que algo pase al pulsar un botón, no ejecutas el código tú: le pasas al botón un trozo de código y él lo ejecuta cuando toca. Si has leído el post de addEventListener, ya lo has hecho en JavaScript. Java tiene lo mismo y se llama lambda.

Una lambda es una función pequeña, sin nombre ni clase, que le pasas a otro método para que la aplique por ti. Es como una nota adhesiva con una instrucción: no la ejecutas tú, la ejecuta quien la recibe, tantas veces como haga falta. Se escribe con los parámetros a la izquierda de la flecha y lo que devuelve a la derecha:

Java: lambdas con nombre 📋
// dentro de main, con la lista pedidos de antes
Predicate<Pedido> esGrande = p -> p.importe() > 100;
Function<Pedido, String> etiqueta = p -> p.cliente() + " (" + p.ciudad() + ")";
System.out.println(esGrande.test(pedidos.get(2)));
System.out.println(etiqueta.apply(pedidos.get(0)));
System.out.println(pedidos.stream().filter(esGrande).map(etiqueta).toList());

La lambda p -> p.importe() > 100 se lee "dado un pedido p, devuelve si su importe supera 100". Predicate<Pedido> es el tipo de una función que recibe un pedido y responde true o false, y Function<Pedido, String> recibe un pedido y devuelve un texto. No tienes que memorizar esos tipos: casi siempre escribirás la lambda directamente donde la necesitas, como vas a ver ahora.

Salida en consola 📋
true
Lucía (Madrid)
[Marta (Madrid), Carmen (Valencia)]

Tu primer Stream: filter y mapToDouble

Ahora sí, el mismo cálculo de antes. Para que lo veas bien, lo escribo entero:

Java: Informe.java con Stream 📋
import java.util.List;

public class Informe {
    record Pedido(String cliente, String ciudad, double importe, String estado) {}

    public static void main(String[] args) {
        List<Pedido> pedidos = List.of(
            new Pedido("Lucía", "Madrid", 89.90, "ENTREGADO"),
            new Pedido("Pablo", "Valencia", 35.00, "ENTREGADO"),
            new Pedido("Marta", "Madrid", 120.50, "PENDIENTE"),
            new Pedido("Iván", "Sevilla", 64.20, "ENTREGADO"),
            new Pedido("Carmen", "Valencia", 210.00, "ENTREGADO"),
            new Pedido("Raúl", "Madrid", 18.75, "CANCELADO")
        );

        double total = pedidos.stream()
            .filter(p -> p.ciudad().equals("Madrid"))
            .filter(p -> p.importe() > 50)
            .mapToDouble(p -> p.importe() * 1.21)
            .sum();
        System.out.printf("Total Madrid con IVA: %.2f €%n", total);
    }
}

Lo que acabas de usar se llama Stream. Piensa en una cinta transportadora de equipajes: los elementos de tu lista pasan por ella de uno en uno, cada operación intermedia (filter, map) es una máquina junto a la cinta que deja pasar o transforma lo que llega, y la última operación (sum, toList, count) es la caja donde cae el resultado. Un Stream no guarda datos, solo describe el camino. Tu lista pedidos sigue intacta.

Aquí filter se queda con los pedidos que cumplen la condición, mapToDouble convierte cada pedido en el número que te interesa (su importe con IVA) y sum los suma. Fíjate en que ya no hay variable acumuladora ni if: cada línea hace una sola cosa.

❌ Error común: olvidar el import

Si copias solo el main a tu proyecto y te sale error: cannot find symbol sobre Collectors o Stream, te falta el import. En los ejemplos que usan Collectors, Stream o Optional añade arriba import java.util.*;, import java.util.function.*; y import java.util.stream.*;. Me pasó con el primero que escribí y estuve cinco minutos mirando el código buscando un fallo que no estaba.

La cinta no arranca sola

Esto me costó pillarlo: un Stream no hace absolutamente nada hasta que añades una operación terminal. Prueba esto, que parece que debería imprimir algo:

Java: sin operación terminal 📋
// dentro de main, con la lista pedidos de antes
pedidos.stream()
    .filter(p -> {
        System.out.println("Revisando a " + p.cliente());
        return p.importe() > 50;
    });
System.out.println("Fin");
Salida en consola 📋
Fin

Compila, no da error y no imprime ningún "Revisando a...". El filtro nunca se ejecutó porque nadie puso la caja al final de la cinta. Es de los fallos más traicioneros, porque el IDE no te avisa. Si le añades un forEach al final, que es una operación terminal, la cinta arranca:

Java: con forEach al final 📋
// dentro de main, con la lista pedidos de antes
pedidos.stream()
    .filter(p -> {
        System.out.println("Revisando a " + p.cliente());
        return p.importe() > 50;
    })
    .forEach(p -> System.out.println("Pasa: " + p.cliente()));
Salida en consola 📋
Revisando a Lucía
Pasa: Lucía
Revisando a Pablo
Revisando a Marta
Pasa: Marta
Revisando a Iván
Pasa: Iván
Revisando a Carmen
Pasa: Carmen
Revisando a Raúl

Mira el orden: cada pedido recorre toda la cinta antes de que entre el siguiente. No se filtra primero toda la lista y luego se imprime; Lucía llega al final, después entra Pablo, que se queda en el filtro porque cobra 35 €. Así es como funciona un Stream por dentro: no crea listas intermedias, y por eso depurarlo cuesta un poco más que un bucle.

Un Stream se usa una sola vez

La cinta es de un solo uso. Si guardas el Stream en una variable e intentas usarlo dos veces, Java se queja:

Java: reutilizar un Stream 📋
// dentro de main, con la lista pedidos de antes
Stream<Pedido> caros = pedidos.stream().filter(p -> p.importe() > 50);
System.out.println(caros.count());
System.out.println(caros.count());
Salida en consola 📋
4
Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.base/java.util.stream.AbstractPipeline.evaluate(...)
	at java.base/java.util.stream.ReferencePipeline.count(...)
	at Informe.main(Informe.java:...)

Fíjate en que el primer count() funciona y el segundo revienta (he recortado la ruta de la excepción). Es una excepción como las del post anterior y se lee igual: primera línea para saber qué pasó, primera línea con tu clase para saber dónde. La solución es no guardar el Stream y volver a crearlo con pedidos.stream() cada vez que lo necesites; es barato.

Lo que una lambda no puede hacer

Otro clásico. Vienes del bucle for, quieres sumar los importes y tu cabeza te dice "uso una variable fuera y la voy incrementando":

Java: acumular dentro de una lambda 📋
// dentro de main, con la lista pedidos de antes
double total = 0;
pedidos.stream().forEach(p -> total += p.importe());
System.out.println(total);
Salida en consola 📋
error: local variables referenced from a lambda expression must be final or effectively final

Una lambda puede leer variables de fuera, pero no cambiarlas. Java lo prohíbe porque la lambda puede ejecutarse más tarde, o en otro hilo, y no quiere que dos sitios pisen la misma variable. No es un capricho: te está empujando hacia la forma correcta, que es dejar que el propio Stream devuelva el resultado con mapToDouble(...).sum(), como en el ejemplo de antes.

map y toList: transformar y recoger

Hasta ahora hemos filtrado y sumado. Lo siguiente más habitual es convertir cada elemento en otra cosa con map y guardar el resultado en una lista nueva. Aquí sacamos los nombres en mayúsculas de los clientes con pedido entregado:

Java: filter, map y toList 📋
// dentro de main, con la lista pedidos de antes
List<String> nombres = pedidos.stream()
    .filter(p -> p.estado().equals("ENTREGADO"))
    .map(p -> p.cliente().toUpperCase())
    .toList();
System.out.println(nombres);
Salida en consola 📋
[LUCÍA, PABLO, IVÁN, CARMEN]

Cuando la lambda solo llama a un método del propio objeto, puedes abreviarla. En vez de p -> p.cliente() escribes Pedido::cliente, que se lee "el método cliente de Pedido". Se llama referencia a método y la verás por todas partes en código real, así que conviene que no te asuste.

❌ Error común: añadir a la lista que devuelve toList()

La lista que te da toList() no se puede modificar. Si luego intentas hacer nombres.add("Nuevo"), Java lanza una UnsupportedOperationException sin mensaje, que es de las excepciones menos amables que hay. Si necesitas una lista que puedas cambiar, envuélvela: new ArrayList<>(pedidos.stream().map(Pedido::cliente).toList()). En código antiguo verás .collect(Collectors.toList()), que es el equivalente de antes de Java 16.

Ordenar y quedarte con unos pocos

Ordenar con Streams es como pulsar la cabecera de una columna en una tabla. sorted recibe el criterio y limit corta la cinta cuando ya tienes los que querías. Aquí van los tres pedidos más grandes:

Java: sorted y limit 📋
// dentro de main, con la lista pedidos de antes
pedidos.stream()
    .sorted(Comparator.comparingDouble(Pedido::importe).reversed())
    .limit(3)
    .forEach(p -> System.out.println(p.cliente() + ": " + p.importe() + " €"));
Salida en consola 📋
Carmen: 210.0 €
Marta: 120.5 €
Lucía: 89.9 €

Comparator.comparingDouble(Pedido::importe) ordena de menor a mayor y .reversed() le da la vuelta. Ese 210.0 con punto y sin formato es porque println no sabe de euros ni de locales; si quieres dos decimales usa printf, como en los ejemplos de arriba.

Contar, promediar y buscar (con Optional)

Otras operaciones terminales que usarás constantemente son count, average, max y anyMatch. Juntas en un ejemplo:

Java: count, average, max y anyMatch 📋
// dentro de main, con la lista pedidos de antes
long entregados = pedidos.stream().filter(p -> p.estado().equals("ENTREGADO")).count();
double media = pedidos.stream().mapToDouble(Pedido::importe).average().orElse(0);
Optional<Pedido> mayor = pedidos.stream().max(Comparator.comparingDouble(Pedido::importe));
boolean hayCancelados = pedidos.stream().anyMatch(p -> p.estado().equals("CANCELADO"));

System.out.println("Entregados: " + entregados);
System.out.printf("Media: %.2f €%n", media);
System.out.println("Mayor: " + mayor.map(Pedido::cliente).orElse("ninguno"));
System.out.println("Hay cancelados: " + hayCancelados);
Salida en consola 📋
Entregados: 4
Media: 89,73 €
Mayor: Carmen
Hay cancelados: true

Fíjate en que max no devuelve un pedido directamente, devuelve un Optional<Pedido>. Un Optional es una caja que puede tener algo dentro o estar vacía. Existe porque una lista vacía no tiene máximo, y Java prefiere que lo tengas en cuenta antes de que explote. Con average pasa lo mismo, y por eso lleva un orElse(0) que dice "si no hay datos, usa 0".

❌ Error común: abrir la caja sin mirar si está vacía

Pedir el máximo de los pedidos de Bilbao, donde no hay ninguno, y abrir la caja directamente con getAsDouble() da una NoSuchElementException. Esto me lo encontré la primera vez que filtré por un dato que no existía.

Java: Optional vacío 📋
// dentro de main, con la lista pedidos de antes
double max = pedidos.stream().filter(p -> p.ciudad().equals("Bilbao")).mapToDouble(Pedido::importe).max().getAsDouble();
System.out.println(max);
Salida en consola 📋
Exception in thread "main" java.util.NoSuchElementException: No value present
	at java.base/java.util.OptionalDouble.getAsDouble(...)
	at Informe.main(Informe.java:...)

La salida correcta es dar un valor por defecto o transformar lo que haya con map y cerrar con orElse:

Java: Optional con orElse 📋
// dentro de main, con la lista pedidos de antes
Optional<Pedido> bilbao = pedidos.stream().filter(p -> p.ciudad().equals("Bilbao")).findFirst();
System.out.println(bilbao.map(Pedido::cliente).orElse("Sin pedidos en Bilbao"));
Salida en consola 📋
Sin pedidos en Bilbao

groupingBy: la tabla dinámica de Java

Si has usado tablas dinámicas en Excel (agrupar por una columna y calcular algo por cada grupo) esto te va a sonar. Collectors.groupingBy hace justo eso. Las ventas totales por ciudad:

Java: groupingBy con summingDouble 📋
// dentro de main, con la lista pedidos de antes
Map<String, Double> porCiudad = pedidos.stream()
    .collect(Collectors.groupingBy(Pedido::ciudad, TreeMap::new, Collectors.summingDouble(Pedido::importe)));
porCiudad.forEach((ciudad, suma) -> System.out.printf("%s: %.2f €%n", ciudad, suma));
Salida en consola 📋
Madrid: 229,15 €
Sevilla: 64,20 €
Valencia: 245,00 €

El primer argumento es por qué columna agrupar, el último es qué calcular en cada grupo. El del medio, TreeMap::new, es opcional pero yo lo pongo siempre: sin él Java usa un HashMap y el orden en que salen las ciudades no está garantizado. Si un día te sale distinto en tu máquina y en la de un compañero, es por eso.

Cambiando solo el último argumento, la misma estructura te da otra cosa. Por ejemplo, los nombres de los clientes de cada ciudad:

Java: groupingBy con mapping 📋
// dentro de main, con la lista pedidos de antes
Map<String, List<String>> clientes = pedidos.stream()
    .collect(Collectors.groupingBy(Pedido::ciudad, TreeMap::new, Collectors.mapping(Pedido::cliente, Collectors.toList())));
System.out.println(clientes);
Salida en consola 📋
{Madrid=[Lucía, Marta, Raúl], Sevilla=[Iván], Valencia=[Pablo, Carmen]}

Mini proyecto: informe de pedidos con IVA

Juntamos todo en un programa que descarta los pedidos cancelados, muestra las ventas por ciudad con IVA del 21%, los dos pedidos más grandes y quién tiene algo pendiente de entregar. Aquí aparece Collectors.joining, que une textos con un separador:

Java: Informe.java 📋
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

public class Informe {
    record Pedido(String cliente, String ciudad, double importe, String estado) {}

    static final double IVA = 0.21;

    static double conIva(double base) {
        return base * (1 + IVA);
    }

    public static void main(String[] args) {
        List<Pedido> pedidos = List.of(
            new Pedido("Lucía", "Madrid", 89.90, "ENTREGADO"),
            new Pedido("Pablo", "Valencia", 35.00, "ENTREGADO"),
            new Pedido("Marta", "Madrid", 120.50, "PENDIENTE"),
            new Pedido("Iván", "Sevilla", 64.20, "ENTREGADO"),
            new Pedido("Carmen", "Valencia", 210.00, "ENTREGADO"),
            new Pedido("Raúl", "Madrid", 18.75, "CANCELADO")
        );

        List<Pedido> validos = pedidos.stream()
            .filter(p -> !p.estado().equals("CANCELADO"))
            .toList();

        System.out.println("Ventas por ciudad (con IVA del 21%)");
        Map<String, Double> porCiudad = validos.stream()
            .collect(Collectors.groupingBy(
                Pedido::ciudad,
                TreeMap::new,
                Collectors.summingDouble(Pedido::importe)));
        porCiudad.forEach((ciudad, suma) ->
            System.out.printf("  %-9s %8.2f €%n", ciudad, conIva(suma)));

        System.out.println("Los dos pedidos más grandes");
        validos.stream()
            .sorted((a, b) -> Double.compare(b.importe(), a.importe()))
            .limit(2)
            .forEach(p -> System.out.printf("  %s: %.2f €%n", p.cliente(), conIva(p.importe())));

        String pendientes = validos.stream()
            .filter(p -> p.estado().equals("PENDIENTE"))
            .map(Pedido::cliente)
            .collect(Collectors.joining(", "));
        System.out.println("Pendientes de entregar: " + (pendientes.isEmpty() ? "ninguno" : pendientes));
    }
}
Salida en consola 📋
Ventas por ciudad (con IVA del 21%)
  Madrid      254,58 €
  Sevilla      77,68 €
  Valencia    296,45 €
Los dos pedidos más grandes
  Carmen: 254,10 €
  Marta: 145,81 €
Pendientes de entregar: Marta

Los números salen del filtro: Madrid suma Lucía y Marta (el pedido de Raúl está cancelado), 89,90 + 120,50 = 210,40 €, y con IVA 254,58 €. Haz la cuenta a mano una vez; es la mejor forma de comprobar que el Stream hace lo que crees.

Cuándo es mejor un for

No todo se arregla con Streams, y me parece importante decirlo. Si necesitas cambiar una variable de fuera, parar a mitad con una lógica rara o ir depurando línea a línea con un breakpoint, el for de toda la vida es mejor. También lo es si el Stream tiene seis operaciones encadenadas y a tu compañero le cuesta un minuto entenderlo.

Un último vicio que verás en código ajeno: usar forEach para rellenar otra lista, como pedidos.forEach(p -> r.add(p.cliente())). Funciona, pero estás usando el Stream como si fuera un bucle. Para eso están map y toList. Y no uses Streams para ir más rápido: se usan por claridad, no por rendimiento.

Ejercicio: clientes de Madrid por orden alfabético

Con la lista de pedidos de este post, saca en un solo String los nombres de los clientes de Madrid que no tengan el pedido cancelado, ordenados alfabéticamente y separados por coma y espacio. Tienes que obtener Lucía, Marta. Pista: sorted() sin argumentos ordena textos por orden alfabético.

Ver la solución (inténtalo tú primero)
Java: solución del ejercicio 📋
// dentro de main, con la lista pedidos de antes
String r = pedidos.stream()
    .filter(p -> p.ciudad().equals("Madrid"))
    .filter(p -> !p.estado().equals("CANCELADO"))
    .map(Pedido::cliente)
    .sorted()
    .collect(Collectors.joining(", "));
System.out.println(r);

Dos filter seguidos hacen de "y" entre condiciones, map se queda solo con el nombre, sorted() ordena y joining junta todo con el separador.

Qué toca ahora

Coge el ejercicio de ArrayList y HashMap o cualquier bucle tuyo que tenga un if dentro y reescríbelo con un Stream. Ejecuta los dos y comprueba que dan lo mismo. Si el resultado no es más corto o más claro, déjalo como estaba; eso también es aprender.

Si quieres seguir con Java, repasa interfaces y clases abstractas: las lambdas que has usado hoy funcionan sobre interfaces de un solo método, y entender por qué te ayudará a leer el código de las librerías.