Cos'è lo Stream API?

Question

Accepted Answer

Lo **Stream API** (Java 8+) abilita l'elaborazione in **stile funzionale** delle collezioni — filtraggio, trasformazione e aggregazione dei dati attraverso una pipeline di operazioni, espressa dichiarativamente (*cosa* fare) piuttosto che con cicli espliciti (*come*). ## Perché è importante ```java // ❌ imperative — explicit loop, mutable accumulator List result = new ArrayList<>(); for (Person p : people) { if (p.getAge() >= 18) { result.add(p.getName().toUpperCase()); } } // ✅ stream — declarative pipeline, reads like a description of the transformation List result = people.stream() .filter(p -> p.getAge() >= 18) // keep adults .map(p -> p.getName().toUpperCase()) // extract + transform names .collect(Collectors.toList()); // gather into a list ``` La versione stream esprime l'intento chiaramente come una catena di operazioni, senza cicli manuali o accumulatori. ## La struttura della pipeline ```text Source → Intermediate operations (lazy) → Terminal operation (triggers execution) ``` ```java stream() // source .filter(...) .map(...) // intermediate — lazy, return a new stream, chainable .collect(...) // terminal — produces a result, RUNS the pipeline ``` Le operazioni **intermedie** (filter, map, sorted, distinct) sono **lazy** — costruiscono la pipeline ma non si eseguono finché un'operazione **terminale** (collect, forEach, reduce, count) non la attiva. ## Operazioni comuni ```java list.stream() .filter(x -> x > 0) // keep matching .map(x -> x * 2) // transform each .sorted() // sort .distinct() // remove duplicates .limit(10) // take first 10 .collect(Collectors.toList()); // aggregations int sum = nums.stream().mapToInt(Integer::intValue).sum(); long count = list.stream().filter(...).count(); Optional first = people.stream().filter(...).findFirst(); boolean any = list.stream().anyMatch(x -> x > 100); // grouping (very powerful) Map> byCity = people.stream().collect(Collectors.groupingBy(Person::getCity)); ``` ## reduce — ridurre a un singolo valore ```java int total = nums.stream().reduce(0, (a, b) -> a + b); // sum via reduction ``` ## Stream paralleli ```java list.parallelStream().filter(...).collect(...); // process across multiple cores // ⚠️ use only for large data + independent/stateless operations; measure first ``` ## Perché è importante Lo Stream API ha trasformato il modo in cui Java elabora i dati — sostituendo i cicli verbosi e soggetti a errori con pipeline concise, leggibili e dichiarative per filtraggio, mapping, ordinamento, raggruppamento e aggregazione. Viene utilizzato ampiamente in Java moderno per la manipolazione dei dati, rende l'intento del codice più chiaro e si integra con lambda e riferimenti a metodi per uno stile funzionale. Comprendere il modello lazy intermedie / eager terminale, le operazioni comuni (filter/map/collect/reduce/groupingBy) e l'opzione di stream paralleli (con i loro avvertimenti) è essenziale per scrivere Java moderno idiomatico. I stream sono sia un aumento della produttività che un argomento frequente nei colloqui, riflettendo la fluidità con le pratiche Java attuali.