1. Qu’est-ce que l’interface Collection
En Java, une interface est comme un « contrat » : si une classe implémente une interface, elle doit fournir l’implémentation de toutes ses méthodes. Une interface, en elle‑même, ne stocke pas d’état et ne contient pas de code (presque : depuis Java 8, des méthodes default sont possibles, mais l’idée de base est ce qui importe ici).
Collection est l’interface de base pour la plupart des collections en Java. Elle définit ce que sait faire une collection : ajouter des éléments, en supprimer, connaître la taille, vérifier la présence d’éléments, etc.
public interface Collection<E> extends Iterable<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
boolean add(E e);
boolean remove(Object o);
void clear();
Iterator<E> iterator();
// ... et encore plein de méthodes utiles
}
Méthodes clés :
- add(E e) — ajouter un élément.
- remove(Object o) — supprimer un élément.
- size() — connaître le nombre d’éléments.
- isEmpty() — vérifier si la collection est vide.
- contains(Object o) — vérifier la présence d’un élément.
- clear() — vider la collection.
- iterator() — obtenir un itérateur pour le parcours.
Pourquoi Map n’hérite-t-il pas de Collection ?
Map est à part parmi les collections. Parce que Map est un ensemble de paires « clé → valeur », et non un simple ensemble d’éléments. Elle a un autre contrat et un autre ensemble de méthodes. Par exemple, dans Map il n’y a pas de méthode add, car l’ajout se fait via put(key, value), et il n’a pas de sens de vérifier la présence d’une valeur sans connaître la clé.
2. Hiérarchie des collections
L’« arbre » mental des interfaces principales ressemble à ceci :
Iterable
|
Collection
/ | \
List Set Queue
|
Deque
- Iterable — l’interface la plus basique : tout ce qui peut être itéré dans une boucle for-each.
- Collection — étend Iterable, ajoute des opérations de manipulation d’une collection d’éléments.
- Trois branches principales :
- List — liste ordonnée, autorise les doublons.
- Set — ensemble d’éléments uniques, l’ordre dépend de l’implémentation.
- Queue — file (souvent FIFO) ; sous-type — Deque (file double).
Et Map vit séparément :
Map
/ \
HashMap TreeMap
Visualisation de la hiérarchie (schéma)
+--------------------+
| Iterable<E> |
+--------------------+
|
+--------------------+
| Collection<E> |
+--------------------+
/ | \
+--------+ +-------+ +-------+
| List | | Set | | Queue |
+--------+ +-------+ +-------+
|
+------+
|Deque |
+------+
+--------------------+
| Map<K,V> |
+--------------------+
3. List : collection ordonnée avec doublons
List est une collection où :
- L’ordre des éléments compte (premier, deuxième, troisième…).
- Des éléments identiques (doublons) sont autorisés.
- On peut obtenir un élément par index (list.get(2)), le remplacer, l’insérer à n’importe quelle position.
Exemples d’implémentations : ArrayList — accès rapide par index ; LinkedList — adapté aux insertions/suppressions fréquentes au milieu.
import java.util.*;
List<String> shoppingList = new ArrayList<>();
shoppingList.add("Lait");
shoppingList.add("Pain");
shoppingList.add("Fromage");
shoppingList.add("Pain"); // Les doublons sont autorisés !
System.out.println(shoppingList.get(1)); // "Pain"
Méthodes typiques de List :
- add(E e), add(int index, E e)
- get(int index), set(int index, E e)
- remove(int index), remove(Object o)
- indexOf(Object o), lastIndexOf(Object o)
4. Set : ensemble d’éléments uniques
Set est une collection où :
- Chaque élément est unique (pas de doublons).
- L’ordre de stockage n’est pas garanti avec HashSet, il peut y avoir un tri avec TreeSet ou l’ordre d’insertion avec LinkedHashSet.
Exemples d’implémentations : HashSet, TreeSet, LinkedHashSet.
import java.util.*;
Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Alice");
uniqueNames.add("Bob");
uniqueNames.add("Alice"); // Ne sera pas ajouté — déjà présent !
System.out.println(uniqueNames.contains("Alice")); // true
System.out.println(uniqueNames.size()); // 2
Méthodes typiques de Set :
- add(E e), remove(Object o)
- contains(Object o)
- size(), isEmpty()
5. Map : collection de paires clé-valeur
Map est une collection où :
- Chaque élément est une paire clé → valeur.
- Les clés sont uniques, les valeurs peuvent se répéter.
- Accès rapide par clé.
Exemples d’implémentations : HashMap, TreeMap, LinkedHashMap.
import java.util.*;
Map<String, String> phoneBook = new HashMap<>();
phoneBook.put("Alice", "+19991112233");
phoneBook.put("Bob", "+19994445566");
phoneBook.put("Alice", "+19990001122"); // Écrasera le numéro d'Alice !
System.out.println(phoneBook.get("Alice")); // "+19990001122"
System.out.println(phoneBook.containsKey("Bob")); // true
Méthodes typiques de Map :
- put(K key, V value), get(K key)
- remove(K key)
- containsKey(K key), containsValue(V value)
- keySet(), values(), entrySet()
6. Visualisation de la hiérarchie : tout sur une image
Petit tableau récapitulatif :
| Interface | Description | Exemples d’implémentations | Caractéristiques clés |
|---|---|---|---|
|
Liste ordonnée | |
Accès par index, doublons |
|
Ensemble de valeurs uniques | |
Éléments tous uniques |
|
Paires clé-valeur | |
Clés uniques, valeurs arbitraires |
Hiérarchie sur le schéma :
Collection
/ | \
List Set Queue
|
Deque
Map (séparément)
7. Quand utiliser quelle interface
List
- Quand l’ordre des éléments est important (par exemple, l’historique des actions de l’utilisateur).
- Quand vous avez besoin de doublons (par exemple, des lignes de commande).
- Quand un accès/remplacement rapide par index est nécessaire.
Set
- Quand vous avez besoin d’unicité (e-mails, identifiants (login), id).
- Quand l’ordre importe peu, ou au contraire — quand un ensemble automatiquement trié est nécessaire (TreeSet).
Map
- Quand il faut associer des clés et des valeurs (id → objet, login → profil).
- Quand vous avez besoin d’une recherche rapide par clé.
- Quand les clés doivent être uniques, mais pas les valeurs.
8. Erreurs typiques lors du travail avec la hiérarchie des collections
Erreur n° 1 : Utiliser une mauvaise interface dans la déclaration de variable. Si vous écrivez ArrayList<String> list = new ArrayList<>();, vous vous liez étroitement à l’implémentation. Il est préférable d’écrire List<String> list = new ArrayList<>(); — il sera ainsi plus simple de remplacer l’implémentation.
Erreur n° 2 : Tenter d’ajouter des doublons dans un Set et s’attendre à ce qu’ils apparaissent. Ce n’est pas un bug, c’est une caractéristique : par définition, un Set ne stocke pas de doublons. L’insertion répétée est ignorée.
Erreur n° 3 : Utiliser Map comme une collection ordinaire. Map n’est ni une liste ni un ensemble. Pour le parcours, utilisez keySet(), values() ou entrySet().
Erreur n° 4 : Attendre un ordre dans HashSet ou HashMap. HashSet et HashMap ne garantissent pas d’ordre. S’il est important — choisissez LinkedHashSet ou LinkedHashMap.
Erreur n° 5 : Utiliser List pour des éléments uniques. Si vous avez besoin d’unicité — utilisez un Set. List ne prévient pas les doublons.
GO TO FULL VERSION