Lezioni

In questa lezione impariamo a raggruppare i dati negli stream con i collector Collectors.groupingBy e Collectors.partitioningBy: raggruppamento semplice e annidato, suddivisione per criterio booleano, scelta tra i due, post-elaborazione del risultato e trucchi. Con esempi pratici su stringhe, numeri e oggetti vedrai come ottenere da uno stream ( Stream API) una Map della struttura desiderata e come lavorare con funzioni-criterio ( Function) e predicati ( Predicate). Alla fine — analisi degli errori tipici.

Immersione pratica nei raggruppamenti annidati con gli Stream e i collector: come combinare Collectors.groupingBy con gli aggregatori ( maxBy, averagingInt, counting), trasformare i dati con mapping, dividere in sottoinsiemi tramite partitioningBy e leggere correttamente le strutture Map annidate. Molti esempi illustrativi, visualizzazione della struttura dei risultati e analisi degli errori tipici.

In questa lezione analizziamo tecniche avanzate con i collettori dello Stream API: collettori downstream annidati per groupingBy/ partitioningBy, trasformazioni con mapping, filtraggio con filtering, «appiattimento» con flatMapping, aggregazione simultanea con teeing (Java 12+), nonché il «congelamento» delle collezioni tramite toUnmodifiableList/Set/Map e collectingAndThen. Mostriamo pipeline pratiche ed errori tipici.

In questa lezione analizzeremo le differenze tra la trasformazione dei dati con map, la trasformazione che «appiattisce» con flatMap e l’alternativa più efficiente introdotta da Java 16+ — mapMulti. Con esempi pratici vedremo chiaramente come scompattare collezioni annidate nel tipo Stream<String> invece di Stream<Stream<String>>, come lavorare con Optional tramite stream(), e quando scegliere mapMulti per ottenere migliori prestazioni senza creare flussi intermedi.

In questa lezione analizziamo i modi per unire i dati nello Stream API: il metodo statico Stream.concat per due stream, la combinazione Stream.of + flatMap per un numero arbitrario di stream, nonché il collector Collectors.joining per incollare gli elementi in un’unica stringa. Parleremo di lazy, natura monouso degli stream, mantenimento dell’ordine ed errori tipici (riutilizzo dello stream, stream infiniti, joining per non stringhe) — con esempi chiari.

In questa lezione analizziamo le operazioni tipiche sugli insiemi in Java: unione ( union), intersezione ( intersection) e differenza ( difference) basate sull’interfaccia Set e sulla Stream API. Sono mostrati esempi pratici con Stream.concat, Stream.of + flatMap, alternative tramite retainAll/ removeAll, nonché aspetti importanti relativi a equals/ hashCode, efficienza ed errori comuni.

In questa lezione vedremo che cos’è zip e perché non esiste nello Stream API standard (fino a Java 22), impareremo ad «accoppiare» le collezioni tramite indici con IntStream.range e a creare stream «al volo» con Stream.iterate e Stream.generate. Esempi, visualizzazioni ed errori tipici ti aiuteranno a usare con sicurezza generazione e zip nei compiti.

Guida dettagliata agli errori più comuni nell'uso dello Stream API in Java: natura monouso dello stream e ripetizione di operazioni terminali ( collect(), forEach(), count()), modifica della collezione durante l'iterazione, limit() dimenticato con stream infiniti ( iterate, generate), gestione di null e lavoro con Optional tramite flatMap(Optional::stream), preservare l’ordine con forEachOrdered(), operazioni insiemistiche efficienti con Set, chiusura corretta delle risorse ( Files.lines + try-with-resources), cautela con parallelStream() e il principio «finché non c’è un operatore terminale, non viene eseguito nulla». Tutti i problemi sono accompagnati da esempi chiari e relative correzioni.

In questa lezione vedremo perché gli stream standard di collezioni di numeri ( Stream<Integer>, Stream<Double>) possono essere inefficienti a causa del boxing/unboxing, e come gli stream primitivi — IntStream, LongStream, DoubleStream — aiutino a evitarlo. Analizzeremo le conversioni mapToInt/ boxed(), le operazioni di aggregazione ( sum(), average(), summaryStatistics()), i risultati sicuri con OptionalInt/ OptionalDouble, nonché dove l’ottimizzazione porta davvero benefici e come misurarne l’effetto con JMH.

In questa lezione vediamo come funziona l'elaborazione pigra nelle Stream API: in cosa differiscono le operazioni intermedie e terminali, perché i calcoli partono solo dopo la chiamata di un terminale, quali vantaggi offrono l'elaborazione elemento per elemento e la «valutazione a corto circuito». Mostreremo catene con filter, map, peek, findFirst, forEach, visualizzeremo il passaggio degli elementi e analizzeremo errori tipici e raccomandazioni per un ordine efficiente delle operazioni.

In questa lezione analizziamo come proteggere i dati con i wrapper immutabili Collections.unmodifiableList, unmodifiableSet, unmodifiableMap, in cosa differiscono l’«immutabilità superficiale» da quella «profonda», quando e perché restituire wrapper dai metodi, nonché le alternative moderne List.of/ Set.of/ Map.of. Parleremo degli errori tipici (per esempio, aspettarsi l’immutabilità profonda o lavorare con null) e del perché i tentativi di modifica terminano con UnsupportedOperationException.

In questa lezione analizziamo che cos’è Spliterator, come consente non solo di iterare gli elementi ma anche di suddividere la sorgente di dati in parti con trySplit(), e come su questa base funzionano gli stream paralleli tramite parallelStream() e il pool condiviso ForkJoinPool. Sono mostrati i metodi chiave ( tryAdvance, estimateSize, characteristics), le caratteristiche tipiche ( ORDERED, SIZED, CONCURRENT e altre), esempi pratici, uno schema Mermaid e gli errori frequenti nell’uso degli stream paralleli.