Leçons

Dans cette leçon, nous verrons comment définir correctement l’égalité des objets en Java : en quoi la comparaison des références avec l’opérateur == diffère de la comparaison du contenu avec la méthode equals, pourquoi le contrat equals/ hashCode est crucial pour des collections comme HashSet et HashMap, et comment relier cela à compareTo de Comparable. Des exemples pas à pas, des bonnes pratiques et l’analyse d’erreurs typiques vous aideront à éviter les pièges lors du travail avec des tables de hachage et des collections triées.

Dans ce cours, nous passons en revue le « couteau suisse » java.util.Objects : comment comparer en toute sécurité avec Objects.equals, calculer des hachages de façon concise avec Objects.hash, déléguer la comparaison via Objects.compare, garantir des valeurs non null avec Objects.requireNonNull, ainsi qu’utiliser Objects.isNull/ Objects.nonNull dans les flux. Nous montrerons une implémentation correcte de equals/ hashCode/ compareTo, analyserons des cas pratiques et les erreurs typiques lors du travail avec HashMap/ HashSet.

Dans cette leçon, nous étudions l’ordre naturel des objets en Java via l’interface Comparable et la méthode compareTo : à quoi elle sert, comment l’implémenter correctement, comment fonctionne le tri des collections ( Collections.sort et List.sort), la comparaison sur plusieurs champs, la gestion des valeurs null et la cohérence avec equals/ hashCode. Nous verrons les bonnes pratiques, les erreurs fréquentes et des exemples pratiques avec la classe Person.

Dans ce cours, nous voyons quand utiliser Comparator plutôt que Comparable, la syntaxe et le contrat de la méthode compare(T o1, T o2), la pratique du tri des listes via Collections.sort et List.sort, la création de comparateurs sous forme de classes séparées, ainsi que via des classes anonymes et des expressions lambda. Nous verrons le tri multi-niveaux, la gestion des valeurs null, la recherche avec Collections.binarySearch, l’inversion d’ordre avec reversed(), ainsi que les bonnes pratiques et les erreurs courantes (par exemple, pourquoi il vaut mieux utiliser Integer.compare plutôt que a - b).

Dans ce cours, nous verrons des techniques pratiques de manipulation des collections : recherche d’éléments avec les méthodes contains, indexOf, lastIndexOf, recherche conditionnelle à l’aide d’une boucle for et de l’instruction break, recherche du minimum et du maximum avec la classe Collections. Nous nous entraînerons à trier des listes avec Collections.sort et List.sort, à utiliser Comparator, à trier les paires d’une Map, ainsi que des objets par champ. Enfin, nous discuterons des erreurs courantes : listes immuables issues de List.of, tentatives de trier Set/ Map et comparateurs incorrects.

Dans ce cours, nous expliquons pourquoi l’approche impérative pour traiter des collections se couvre rapidement de boilerplate, et comment Stream API fait passer le code à un style déclaratif : des chaînes d’opérations filter, map, collect, une composition simple, moins d’erreurs et un parallélisme facile via parallelStream(). Nous montrerons les cas d’usage, l’historique et les erreurs typiques à éviter.

Découverte pas à pas des opérations de base de l’API Stream: comment obtenir un flux à partir d’une collection et d’un tableau ( stream(), Arrays.stream, Stream.of), en quoi les opérations intermédiaires ( filter, map, distinct) diffèrent des opérations terminales ( collect, forEach, count), et comment rassembler les résultats avec Collectors ( toList, toSet, joining). Des exemples concrets, des mini‑exercices et une section sur les erreurs courantes vous aideront à maîtriser rapidement le traitement des données en pipeline.

Dans ce cours, nous étudions trois opérations clés de l’API Stream pour travailler avec des sous-ensembles de données : distinct (suppression des doublons), limit (limitation du nombre d’éléments) et skip (saut des premiers éléments). Vous verrez comment elles fonctionnent sur des collections de chaînes et d’objets, en quoi l’implémentation de equals/ hashCode influe sur le résultat de distinct, comment combiner les opérations pour la pagination et la sélection des top‑N, ainsi que les erreurs les plus fréquentes.

Dans cette leçon, nous abordons les opérations de flux pour les effets secondaires : l’opération terminale forEach et l’intermédiaire peek. Nous comprendrons quand et pourquoi les utiliser, en quoi elles diffèrent, pourquoi après forEach le flux « se ferme », tandis que peek ne modifie pas les données et ne s’exécute qu’en présence d’une opération terminale. Nous montrerons des exemples pratiques, clarifierons des points peu évidents et les erreurs typiques (y compris ConcurrentModificationException et le mauvais remplacement de collect par forEach).

Guide pratique pour transformer des collections avec Stream API : conversion List ↔ Set, construction de mappages via Collectors.toMap() (y compris la gestion des doublons), concaténation en chaîne avec Collectors.joining(), analyse des opérations terminales et intermédiaires ( forEach, collect, count, anyMatch, etc.). Au programme – des exemples clairs, des explications et des erreurs courantes.

Dans ce cours, nous passons en revue les opérations d’agrégation de l’API Stream : comment compter avec count(), calculer des sommes et des moyennes avec les streams primitifs ( IntStream, LongStream, DoubleStream) et les méthodes sum(), average(), ainsi que trouver les extrêmes avec min()/ max(). Nous parlerons séparément des conteneurs Optional, OptionalInt, OptionalLong, OptionalDouble et des façons correctes d’extraire les valeurs : orElse(...), ifPresent(...), orElseThrow(). Nous apprendrons à utiliser les collecteurs Collectors.summingInt, Collectors.averagingInt, Collectors.maxBy/ minBy et à les combiner avec groupingBy. Pour finir — analyse des erreurs courantes et des subtilités.

Nous étudions les opérations terminales des flux: la réduction universelle reduce() et le puissant collecteur collect(). Nous comprendrons les signatures avec identity, accumulator et combiner, apprendrons à rassembler les données avec les collecteurs prêts à l’emploi de Collectors ( toList(), toMap(), joining(), groupingBy()) et verrons quand il vaut mieux préférer collect() à reduce(). Nous aborderons séparément le travail avec Optional, le traitement des doublons dans toMap() et les subtilités des flux parallèles.