Formations — 1 037 leçons en français

Accueil › Java › Comprendre un stream

Comprendre un stream

Les streamsintermediaire

Un stream décrit un calcul sur une séquence d'éléments : filtrer, transformer, agréger. Ce n'est pas une structure de données — il ne stocke rien, il lit sa source à la demande et ne se parcourt qu'une seule fois.

List<String> categories = List.of("Livres", "Jeux", "Musique", "Jardin");

long nbCourtes = categories.stream()      // source
    .filter(c -> c.length() <= 5)         // opération intermédiaire
    .count();                             // opération terminale

Un pipeline a toujours cette forme : une source (collection.stream(), Stream.of(...), Arrays.stream(tableau), Files.lines(chemin), IntStream.range(0, 10)…), zéro ou plusieurs opérations intermédiaires qui renvoient un nouveau stream, et exactement une opération terminale qui déclenche le calcul et produit un résultat.

Les opérations intermédiaires sont paresseuses : filter et map ne font rien tant qu'aucune opération terminale n'a été invoquée. C'est cette dernière qui parcourt réellement les éléments.

stream().filter(c -> c.length() <= 5).map(String::toUpperCase).findFirst() source filter map findFirst lit à la demande paresseux paresseux déclenche tout le calcul Élément par élément, de bout en bout « Livres » filter : longueur 6 → rejeté, on passe au suivant « Jeux » filter ✓ → map : « JEUX » → findFirst : trouvé « Musique » jamais lu « Jardin » jamais lu map n'est appelé qu'une seule fois, pas quatre. Chaque élément traverse tout le pipeline avant que le suivant ne démarre.
Un stream n'est pas une suite d'étapes sur des collections intermédiaires : c'est un seul parcours, élément par élément, qui s'arrête dès que le résultat est connu.

Un stream se consomme une seule fois : une fois l'opération terminale exécutée, réutiliser le même objet Stream lève une IllegalStateException. Pour retraiter les mêmes données, il faut recréer un stream depuis la source.

Pour les types primitifs (int, long, double), IntStream, LongStream et DoubleStream évitent l'autoboxing et ajoutent des opérations numériques (sum(), average()).

Les termes à connaître

Stream

Une séquence d'éléments sur laquelle on décrit un calcul en chaîne (filtrer, transformer, agréger…). Un stream ne stocke rien : ce n'est pas une structure de données, seulement une abstraction de traitement qui lit sa source à la demande.

Pipeline

L'enchaînement complet d'un traitement par stream : une source (list.stream()…), zéro ou plusieurs opérations intermédiaires (filter, map…) et exactement une opération terminale (collect, forEach…) qui déclenche réellement le calcul.

Opération intermédiaire

Opération qui renvoie un nouveau Stream (filter, map, sorted…) sans rien exécuter immédiatement. Elle se contente d'enregistrer une étape du pipeline ; le traitement effectif attend l'opération terminale.

Opération terminale

Opération qui déclenche l'évaluation du pipeline et produit un résultat (une valeur, une collection) ou un effet de bord (forEach), puis consomme le stream : celui-ci devient inutilisable ensuite.

Paresse (laziness)

Propriété des opérations intermédiaires : elles ne font aucun travail tant qu'aucune opération terminale n'a été appelée. Sans opération terminale, un pipeline entier ne s'exécute jamais.

IntStream / LongStream / DoubleStream

Variantes spécialisées pour les types primitifs (int, long, double) qui évitent l'autoboxing et ajoutent des opérations numériques (sum(), average(), summaryStatistics()).

Stream.iterate / Stream.generate

Deux façons de créer un stream potentiellement infini : iterate applique une fonction de façon répétée à partir d'une valeur de départ, generate appelle un Supplier à chaque élément. Toujours les borner avec limit(n) (ou une condition d'arrêt pour iterate), sous peine de boucle infinie.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.