Leçons

Dans cette leçon, nous apprenons à regrouper des données dans des flux à l’aide des collecteurs Collectors.groupingBy et Collectors.partitioningBy : regroupement simple et imbriqué, partition selon un prédicat booléen, choix entre les deux, post-traitement du résultat et astuces. À l’aide d’exemples pratiques sur des chaînes, des nombres et des objets, vous verrez comment obtenir une Map de la structure souhaitée à partir d’un flux ( Stream API) et comment travailler avec des fonctions-clés ( Function) et des prédicats ( Predicate). À la fin — analyse des erreurs typiques.

Immersion pratique dans les groupements imbriqués avec les Streams et les collecteurs : comment combiner Collectors.groupingBy avec des agrégateurs ( maxBy, averagingInt, counting), transformer les données avec mapping, découper en sous-ensembles via partitioningBy et lire correctement les structures Map imbriquées. De nombreux exemples parlants, une visualisation de la structure des résultats et une analyse des erreurs typiques.

Dans ce cours, nous abordons des techniques avancées avec les collecteurs du Stream API : collecteurs downstream imbriqués pour groupingBy/ partitioningBy, transformations avec mapping, filtrage avec filtering, « aplatissement » avec flatMapping, agrégation simultanée avec teeing (Java 12+), ainsi que le « gel » des collections via toUnmodifiableList/Set/Map et collectingAndThen. Nous montrons des pipelines pratiques et les erreurs typiques.

Dans cette leçon, nous allons voir en quoi diffère la transformation des données via map, la transformation « aplatisseuse » via flatMap et l’alternative plus performante à partir de Java 16+ — mapMulti. Au moyen d’exemples pratiques, nous verrons concrètement comment décompacter des collections imbriquées pour obtenir un Stream<String> au lieu d’un Stream<Stream<String>>, comment travailler avec Optional via stream(), ainsi que quand choisir mapMulti pour des raisons de performance sans créer de flux intermédiaires.

Dans cette leçon, nous étudions les façons de fusionner des données avec le Stream API: la méthode statique Stream.concat pour deux flux, la combinaison Stream.of + flatMap pour un nombre arbitraire de flux, ainsi que le collecteur Collectors.joining pour concaténer des éléments en une seule chaîne. Nous parlerons du caractère paresseux (lazy), de l’usage unique des streams, de la conservation de l’ordre et des erreurs typiques (réutilisation d’un flux, streams infinis, joining pour des non-chaînes) — avec des exemples concrets.

Dans cette leçon, nous passons en revue les opérations typiques sur les ensembles en Java : union ( union), intersection ( intersection) et différence ( difference) sur la base de l’interface Set et de la Stream API. Des exemples pratiques sont présentés avec Stream.concat, Stream.of + flatMap, des alternatives via retainAll/ removeAll, ainsi que des nuances importantes à propos de equals/ hashCode, de l’efficacité et des erreurs courantes.

Dans ce cours, nous verrons ce qu’est zip et pourquoi il n’existe pas dans l’ Stream API standard (jusqu’à Java 22), nous apprendrons à « apparier » des collections via des index à l’aide de IntStream.range, ainsi qu’à créer des flux « à la volée » avec Stream.iterate et Stream.generate. Des exemples, des visualisations et des erreurs typiques vous aideront à utiliser sereinement la génération et le zip dans vos exercices.

Guide détaillé des erreurs fréquentes avec l’API Stream en Java : nature à usage unique d’un flux et répétition d’opérations terminales ( collect(), forEach(), count()), modification de la collection pendant l’itération, limit() oublié avec des flux infinis ( iterate, generate), gestion de null et travail avec Optional via flatMap(Optional::stream), préservation de l’ordre avec forEachOrdered(), opérations d’ensembles efficaces avec Set, fermeture correcte des ressources ( Files.lines + try-with-resources), prudence avec parallelStream() et principe « tant qu’il n’y a pas d’opération terminale — rien n’est exécuté ». Tous les problèmes sont accompagnés d’exemples clairs et de corrections.

Dans ce cours, nous verrons pourquoi les flux classiques de collections de nombres ( Stream<Integer>, Stream<Double>) peuvent être inefficaces à cause du boxing/unboxing, et comment les flux primitifs — IntStream, LongStream, DoubleStream — permettent d’éviter ces surcoûts. Nous examinerons les conversions mapToInt/ boxed(), les opérations d’agrégation ( sum(), average(), summaryStatistics()), les résultats sûrs avec OptionalInt/ OptionalDouble, ainsi que les cas où l’optimisation apporte réellement un gain et comment mesurer l’effet avec JMH.

Dans ce cours, nous expliquons le fonctionnement du traitement paresseux dans l’API Stream : quelles sont les différences entre opérations intermédiaires et terminales, pourquoi les calculs ne démarrent qu’après l’appel d’une opération terminale, et quels avantages offrent le traitement élément par élément et les « calculs courts ». Nous montrerons des chaînes avec filter, map, peek, findFirst, forEach, visualiserons le passage des éléments et aborderons les erreurs typiques ainsi que des recommandations pour un ordre d’opérations efficace.

Dans cette leçon, nous voyons comment protéger les données à l’aide de vues non modifiables Collections.unmodifiableList, unmodifiableSet, unmodifiableMap, en quoi l’immuabilité « superficielle » diffère de l’immuabilité « profonde », quand et pourquoi renvoyer des vues depuis des méthodes, ainsi que les alternatives modernes List.of/ Set.of/ Map.of. Nous parlerons des erreurs typiques (par exemple, s’attendre à une immuabilité profonde ou manipuler null) et des raisons pour lesquelles les tentatives de modification se terminent par une UnsupportedOperationException.

Dans ce cours, nous expliquons ce qu’est un Spliterator, comment il permet non seulement d’itérer sur les éléments, mais aussi de découper la source de données en parties à l’aide de trySplit(), comment les flux parallèles fonctionnent sur cette base via parallelStream() et le pool commun ForkJoinPool. Nous montrons les méthodes clés ( tryAdvance, estimateSize, characteristics), les caractéristiques typiques ( ORDERED, SIZED, CONCURRENT, etc.), des exemples pratiques, un schéma Mermaid et des erreurs fréquentes lors de l’utilisation des flux parallèles.