La Collections Framework est l'ensemble unifié des interfaces et des classes de Java pour stocker et manipuler des groupes d'objets — List, Set, Map, Queue et leurs implémentations. Elle fournit des structures de données prêtes à l'emploi et bien testées, ce qui vous évite de les construire vous-même.
Collection
├── List — ordered, allows duplicates, indexed access
├── Set — no duplicates, models uniqueness
└── Queue — FIFO/priority ordering for processing
Map (separate hierarchy) — key→value pairs
List<String> list = new ArrayList<>(); // backed by an array — fast random access
list.add("a");
list.get(0); // index access — O(1)
list.contains("a"); // O(n) search
// LinkedList — fast insert/remove at ends, O(n) random access
ArrayList (appuyée par un tableau, indexage rapide) est la valeur par défaut ; LinkedList convient aux insertions fréquentes en fin.
Set<String> set = new HashSet<>(); // O(1) add/contains, NO order
set.add("a");
set.add("a"); // ignored — duplicates not allowed
set.contains("a"); // O(1) — great for membership tests
// TreeSet — sorted order; LinkedHashSet — insertion order
HashSet offre des vérifications d'unicité en O(1) ; TreeSet maintient les éléments triés.
Map<String, Integer> map = new HashMap<>(); // O(1) get/put, no order
map.put("age", 30);
map.get("age"); // 30
map.getOrDefault("x", 0); // safe access with default
map.computeIfAbsent("list", k -> new ArrayList<>()); // handy for grouping
// TreeMap — sorted by key; LinkedHashMap — insertion order
HashMap est le standard pour une recherche basée sur les clés en O(1).
Need ordered + indexed + duplicates → ArrayList
Need uniqueness, fast lookup → HashSet
Need key→value, fast lookup → HashMap
Need sorted order → TreeSet / TreeMap
Need FIFO processing → ArrayDeque / LinkedList (Queue)
Need thread-safety → ConcurrentHashMap, etc.
ArrayList: get O(1), add-end O(1), contains/remove O(n)
HashMap/HashSet: get/put/contains O(1) average
TreeMap/TreeSet: O(log n) (sorted)
LinkedList: add/remove-ends O(1), get O(n)
La Collections Framework est parmi les parties les plus utilisées de Java — presque chaque programme stocke et traite des groupes de données avec elle.
Choisir la bonne collection est une compétence clé qui affecte directement la correction et les performances : ArrayList pour les données indexées ordonnées, HashSet pour l'unicité, HashMap pour les recherches rapides par clé, et les variantes triées/concurrentes si nécessaire.
Comprendre les interfaces (List/Set/Map/Queue), leurs implémentations, et surtout les caractéristiques de performance (recherche O(1) HashMap vs recherche O(n) dans une liste) vous permet de choisir la structure appropriée plutôt que de vous rabattre sur la mauvaise (une cause courante de code lent).
C'est une connaissance fondamentale et pratique pour le développement Java au quotidien.