Leçons

Dans cette leçon, nous étudions l’interface Set en Java : en quoi elle diffère de List, comment l’unicité des éléments est assurée, comment fonctionnent les implémentations HashSet (rapide, sans ordre) et TreeSet (trié), et quand choisir telle ou telle structure. Nous examinerons des nuances importantes à propos de equals() et hashCode(), la gestion de null, des exemples de tâches types (suppression des doublons, vérification de l’unicité) et des erreurs fréquentes.

Nous passons des collections « brutes » à un code sûr du point de vue des types. Dans cette leçon, nous expliquons pourquoi, avant l’apparition des génériques, les collections basées sur Object menaient à des erreurs à l’exécution ( ClassCastException), comment les generics résolvent cela au moment de la compilation, comment lire et écrire des constructions comme List<String>, Map<String, Integer>, ce qu’est l’« opérateur diamant » <> et à quoi sert l’effacement de types (type erasure). En plus, des exemples avec des classes génériques personnelles et un passage en revue des erreurs typiques.

Nous passons en revue les bases des collections Java : l’interface Collection et ses branches List, Set, Queue/ Deque, ainsi que la hiérarchie séparée Map. Vous verrez pourquoi Map n’hérite pas de Collection, à quoi ressemble la hiérarchie, en quoi les implémentations diffèrent, quelles méthodes sont essentielles et quand choisir quoi. À la fin — les erreurs typiques et comment les éviter.

Dans ce cours, nous expliquons comment travailler avec les interfaces Iterable et Iterator : ce que fait la méthode iterator(), comment la boucle for-each fonctionne « en coulisses », quand et pourquoi utiliser manuellement hasNext() et next(), comment supprimer des éléments en toute sécurité via remove() sans déclencher ConcurrentModificationException, ainsi que comment parcourir correctement une Map à l’aide de keySet(), values() et entrySet(). De nombreux exemples pratiques et des erreurs fréquentes pour consolider les connaissances.

Dans cette leçon, nous étudions les files et les piles en Java : comment fonctionnent les principes FIFO et LIFO, en quoi diffèrent Queue, Deque et Stack, pourquoi choisir ArrayDeque dans les projets modernes, et comment utiliser en toute sécurité les méthodes offer/ poll/ peek et push/ pop/ peek. Nous montrerons des exemples avec LinkedList, PriorityQueue, des mini‑applications d’impression et de pile d’annulation (undo), ainsi qu’un passage en revue des erreurs typiques.

Dans ce cours, nous étudions les collections ordonnées et navigables de Java : NavigableSet et NavigableMap. En pratique, nous verrons comment travailler avec des plages via subSet/ headSet/ tailSet, rechercher des éléments « proches » à l’aide de lower, floor, ceiling, higher et gérer les extrémités avec pollFirst/ pollLast. Nous examinerons les représentations inversées descendingSet/ descendingMap, les vues « live » et des cas typiques (planning, priorités, barèmes). Comme implémentations, nous utiliserons TreeSet et TreeMap.

Dans ce cours, nous analysons l’invariance des génériques en Java, les bornes des paramètres de type ( extends/ super), les types joker ? et la règle PECS (« Producer Extends, Consumer Super »). Nous verrons comment écrire des méthodes génériques universelles avec des jokers, comment fonctionne l’effacement de type (type erasure), les restrictions avec instanceof et les tableaux, ainsi que de la pratique avec les collections et l’API Stream. Pour finir — les erreurs fréquentes et comment les éviter.

Dans ce cours, nous abordons la pratique du filtrage des collections en Java : approche impérative via une boucle for, suppression sûre pendant l’itération à l’aide de Iterator et de la méthode remove(), ainsi qu’une solution moderne et concise removeIf (Java 8+). Nous verrons pourquoi une ConcurrentModificationException survient, quand il convient de créer une nouvelle liste, et quelles erreurs typiques se rencontrent le plus souvent lors de la formulation des conditions de filtrage.

Dans ce cours, nous expliquons comment réaliser de manière impérative la transformation de collections : à partir d’une List<String>, obtenir une List<Integer> (par exemple, les longueurs des chaînes), comment extraire des champs d’objets du modèle de domaine ( Product → nom/prix), comment « aplatir » des collections imbriquées via addAll() ou des boucles imbriquées, ainsi que comment combiner filtrage et transformation à l’aide de if et de méthodes comme startsWith. Enfin, nous passerons en revue les erreurs typiques : modification de la collection d’origine, transtypage incorrect ( ClassCastException) et questions de performance.

Dans la pratique, la suppression d’éléments dans les collections conduit souvent à une ConcurrentModificationException. Dans cette leçon, nous verrons pourquoi cela se produit lors d’un parcours via for-each, comment supprimer en toute sécurité avec Iterator.remove(), en quoi ListIterator est utile, quand choisir removeIf (Java 8+) et comment travailler correctement avec Map. À la fin — conseils pratiques et erreurs typiques.

Dans ce cours, nous étudions des collections spécialisées pour les énumérations — EnumSet et EnumMap du package java.util : leur fonctionnement interne (masques binaires et indexation par ordinal), en quoi elles sont plus rapides et plus compactes que HashSet/ HashMap, où les utiliser (drapeaux, tables de correspondance, automates finis), les pièges liés aux modifications de l' enum et à la sérialisation, ainsi qu’un ensemble de bonnes pratiques et d’erreurs typiques avec des exemples de code parlants.

Dans ce cours, nous étudions les collections qui mémorisent l’ordre : LinkedHashSet et LinkedHashMap. Vous apprendrez comment elles maintiennent l’ordre d’insertion et l’ordre d’accès, comment construire en quelques lignes un cache LRU via la redéfinition de removeEldestEntry, quels sont les coûts mémoire et performance par rapport à HashSet/ HashMap, quand un ordre déterministe est nécessaire pour des tests et des rapports stables, ainsi que pourquoi, pour les files/piles, ArrayDeque est préférable à LinkedList. Pour finir — les erreurs typiques et comment les éviter.