Lecciones

En esta lección aprendemos a agrupar datos en streams con los colectores Collectors.groupingBy y Collectors.partitioningBy: agrupación simple y anidada, partición por un criterio booleano, cómo elegir entre ellos, procesamiento del resultado y trucos. Con ejemplos prácticos con cadenas, números y objetos verás cómo obtener un Map de la estructura necesaria a partir de un stream ( Stream API) y cómo trabajar con funciones-criterio ( Function) y predicados ( Predicate). Al final, análisis de errores típicos.

Inmersión práctica en agrupaciones anidadas con Streams y colectores: cómo combinar Collectors.groupingBy con agregadores ( maxBy, averagingInt, counting), transformar datos con mapping, dividir en subconjuntos mediante partitioningBy y leer correctamente estructuras anidadas de Map. Muchos ejemplos ilustrativos, visualización de la estructura de los resultados y análisis de errores típicos.

En la lección analizamos técnicas avanzadas con los colectores de Stream API: colectores downstream anidados para groupingBy/ partitioningBy, transformaciones con mapping, filtrado con filtering, «aplanamiento» con flatMapping, agregación simultánea con teeing (Java 12+), así como la «congelación» de colecciones mediante toUnmodifiableList/Set/Map y collectingAndThen. Mostramos canalizaciones prácticas y errores típicos.

En esta lección veremos en qué se diferencia la transformación de datos mediante map, la transformación «aplanadora» con flatMap y el análogo más eficiente desde Java 16+ — mapMulti. Con ejemplos prácticos veremos claramente cómo desempaquetar colecciones anidadas al tipo Stream<String> en lugar de Stream<Stream<String>>, cómo trabajar con Optional a través de stream(), y también cuándo elegir mapMulti por razones de rendimiento sin crear flujos intermedios.

En esta lección analizamos las formas de combinar datos en el Stream API: el método estático Stream.concat para dos streams, la combinación de Stream.of + flatMap para un número arbitrario de streams, así como el collector Collectors.joining para pegar elementos en una sola cadena. Hablaremos de la evaluación perezosa, del carácter de un solo uso de los streams, del mantenimiento del orden y de errores típicos (reutilización del stream, streams infinitos, joining para no cadenas) — con ejemplos claros.

En esta lección repasamos las operaciones típicas sobre conjuntos en Java: unión ( union), intersección ( intersection) y diferencia ( difference) basadas en la interfaz Set y en la Stream API. Se muestran ejemplos prácticos con Stream.concat, Stream.of + flatMap, alternativas mediante retainAll/ removeAll, así como matices importantes sobre equals/ hashCode, eficiencia y errores comunes.

En la lección veremos qué es zip y por qué no está en el Stream API estándar (hasta Java 22), aprenderemos a «emparejar» colecciones por índices con IntStream.range, así como a crear streams «sobre la marcha» con Stream.iterate y Stream.generate. Ejemplos, visualizaciones y errores típicos te ayudarán a aplicar con seguridad la generación y el zip en las tareas.

Guía detallada sobre errores frecuentes al trabajar con la API de Stream en Java: la naturaleza de un solo uso del stream y las operaciones terminales repetidas ( collect(), forEach(), count()), la modificación de la colección durante la iteración, el limit() olvidado en streams infinitos ( iterate, generate), el manejo de null y el trabajo con Optional mediante flatMap(Optional::stream), la preservación del orden con forEachOrdered(), operaciones eficientes de conjuntos con Set, el cierre correcto de recursos ( Files.lines + try-with-resources), precaución con parallelStream() y el principio «mientras no haya un operador terminal — no se ejecuta nada». Todos los problemas vienen acompañados de ejemplos claros y soluciones.

En la lección veremos por qué los streams habituales de colecciones numéricas ( Stream<Integer>, Stream<Double>) pueden ser ineficientes debido al boxing/unboxing, y cómo los streams primitivos — IntStream, LongStream, DoubleStream — ayudan a evitarlo. Analizaremos las conversiones mapToInt/ boxed(), las operaciones de agregación ( sum(), average(), summaryStatistics()), los resultados seguros con OptionalInt/ OptionalDouble, así como dónde la optimización realmente aporta mejoras y cómo medir el efecto con JMH.

En la lección explicamos cómo funciona la evaluación perezosa en la API de Stream: en qué se diferencian las operaciones intermedias y las terminales, por qué los cálculos empiezan solo tras llamar a una terminal, y qué ventajas aportan el procesamiento elemento a elemento y los «cálculos cortos». Mostraremos cadenas con filter, map, peek, findFirst, forEach, visualizaremos el paso de los elementos y analizaremos errores típicos y recomendaciones sobre el orden eficiente de operaciones.

En la lección analizamos cómo proteger los datos con envolturas inmutables Collections.unmodifiableList, unmodifiableSet, unmodifiableMap, en qué se diferencia la inmutabilidad «superficial» de la «profunda», cuándo y por qué devolver envolturas desde los métodos, así como las alternativas modernas List.of/ Set.of/ Map.of. Hablaremos de errores típicos (por ejemplo, esperar inmutabilidad profunda o trabajar con null) y de por qué los intentos de modificación terminan en UnsupportedOperationException.

En la lección vemos qué es Spliterator, cómo permite no solo iterar elementos, sino también dividir la fuente de datos en partes con trySplit(), cómo sobre esta base funcionan los streams paralelos mediante parallelStream() y el pool común ForkJoinPool. Se muestran los métodos clave ( tryAdvance, estimateSize, characteristics), las características típicas ( ORDERED, SIZED, CONCURRENT, etc.), ejemplos prácticos, un diagrama Mermaid y errores comunes al usar streams paralelos.