Qu'est-ce que la Stream API ?

Question

Accepted Answer

La **Stream API** (Java 8+) permet le traitement **en style fonctionnel** des collections — filtrage, transformation et agrégation de données via un pipeline d'opérations, exprimé de manière déclarative (*quoi* faire) plutôt qu'avec des boucles explicites (*comment*). ## Imperative vs Stream style ```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 version stream exprime l'intention clairement comme une chaîne d'opérations, sans boucle manuelle ni accumulateur. ## The pipeline structure ```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 ``` Les opérations **intermédiaires** (filter, map, sorted, distinct) sont **lazy** — elles construisent le pipeline mais ne s'exécutent que lorsqu'une opération **terminale** (collect, forEach, reduce, count) la déclenche. ## Common operations ```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 — fold to a single value ```java int total = nums.stream().reduce(0, (a, b) -> a + b); // sum via reduction ``` ## Parallel streams ```java list.parallelStream().filter(...).collect(...); // process across multiple cores // ⚠️ use only for large data + independent/stateless operations; measure first ``` ## Pourquoi c'est important La Stream API a transformé la façon dont Java traite les données — remplaçant les boucles verbeuses et sujettes aux erreurs par des pipelines concis, lisibles et déclaratifs pour le filtrage, le mapping, le tri, le regroupement et l'agrégation. Elle est largement utilisée dans le Java moderne pour la manipulation de données, rend l'intention du code plus claire, et s'intègre avec les lambdas et les références de méthodes pour un style fonctionnel. Comprendre le modèle lazy intermédiaire / eager terminal, les opérations communes (filter/map/collect/reduce/groupingBy) et l'option des streams parallèles (avec leurs limitations) est essentiel pour écrire du Java moderne idiomatique. Les streams sont à la fois un gain de productivité et un sujet fréquent aux entretiens, reflétant la maîtrise des pratiques Java actuelles.