Les Collections en Java
Cours de Programmation Java — [Link]
1. Définition
Les collections sont des objets qui permettent de manipuler des structures de données
dynamiques : vecteurs, listes chaînées, ensembles, tables de hachage, etc.
2. Inconvénients des Tableaux Statiques
Un tableau simple en Java présente plusieurs limitations importantes :
❌ Manque d'ordre — pas de tri automatique
❌ Ne gère pas les doublons
❌ Problème de taille fixe — impossible d'ajouter ou supprimer des éléments
dynamiquement
❌ Ne peut pas être ordonné facilement
❌ Problème d'accès direct — recherche non optimisée
Les collections Java sont les outils qui permettent de pallier ces limitations : c'est un
💡 ensemble de classes et d'interfaces gérant des structures dynamiques, disponibles dans le
package [Link].
3. Les Interfaces Principales
Interface Description Implémentations courantes
Collection Racine de la hiérarchie —
List Séquence ordonnée avec doublons ArrayList, LinkedList, Vector
Set Ensemble sans doublons HashSet, TreeSet, LinkedHashSet
SortedSet Ensemble trié (ordre naturel) TreeSet
Map Association clé → valeur HashMap, TreeMap, LinkedHashMap
SortedMap Map triée par clé TreeMap
4. Les Ensembles (Set)
Il existe deux grandes familles d'ensembles :
• HashSet — ensemble non trié, accès rapide (O(1))
• TreeSet / SortedSet — ensemble trié automatiquement selon l'ordre naturel des
éléments (Comparable) ou un Comparator fourni
• LinkedHashSet — conserve l'ordre d'insertion
SortedSet est trié par rapport à l'ordre naturel des éléments (compareTo) ou selon un
📌 Comparator passé au constructeur.
// HashSet — sans ordre
Set<String> hs = new HashSet<>();
// TreeSet — trié par ordre naturel (A, B, C...)
Set<String> ts = new TreeSet<>();
// TreeSet — trié par Comparator personnalisé
Set<Etudiant> ts = new TreeSet<>([Link](Etudiant::getTaille));
5. Parcourir une Collection — L'Itérateur
On parcourt une collection grâce à la notion d'itérateur. Un itérateur est un objet qui permet de
traverser une collection élément par élément sans connaître sa structure interne.
Type d'itérateur Interface Sens de parcours
Itérateur simple Iterator<E> Un seul sens (avant)
Itérateur bidirectionnel ListIterator<E> Avant et arrière (next / previous)
// Utilisation d'un Iterator
Iterator<String> it = [Link]();
while ([Link]()) {
String s = [Link]();
[Link](s);
}
// Utilisation d'un ListIterator (bidirectionnel)
ListIterator<String> lit = [Link]();
while ([Link]()) {
[Link]([Link]());
}
// Syntaxe simplifiée (for-each)
for (String s : maListe) {
[Link](s);
}
6. L'Interface Map — Clé / Valeur
L'interface Map permet de créer des associations clé → valeur. Chaque clé est unique, mais
les valeurs peuvent se répéter.
Implémentation Ordre des clés Doublons de clés
HashMap Aucun ordre garanti Non
TreeMap Trié par ordre naturel Non
LinkedHashMap Ordre d'insertion Non
// Création d'une Map
Map<String, Integer> notes = new HashMap<>();
[Link]("Alice", 18);
[Link]("Bob", 15);
// Parcours d'une Map
for ([Link]<String, Integer> e : [Link]()) {
[Link]([Link]() + " : " + [Link]());
}
7. Exercices Pratiques
Exercice 1 — ArrayList et tri par nom/prénom
Créer une classe Etudiant(nom, prenom, taille), construire une ArrayList d'étudiants, trier par
📝 nom puis prénom, et afficher la liste.
import [Link].*;
class Etudiant implements Comparable<Etudiant> {
private String nom, prenom;
private double taille;
public Etudiant(String nom, String prenom, double taille) {
[Link] = nom; [Link] = prenom; [Link] = taille;
}
public String getNom() { return nom; }
public String getPrenom() { return prenom; }
public double getTaille() { return taille; }
// Ordre naturel : par nom puis prénom
@Override
public int compareTo(Etudiant o) {
int cmp = [Link]([Link]);
return cmp != 0 ? cmp : [Link]([Link]);
}
@Override
public String toString() {
return nom + " " + prenom + " (" + taille + "m)";
}
}
public class Exo1 {
public static void main(String[] args) {
List<Etudiant> liste = new ArrayList<>();
[Link](new Etudiant("Martin", "Alice", 1.65));
[Link](new Etudiant("Bernard", "Bob", 1.80));
[Link](new Etudiant("Martin", "Charlie",1.72));
[Link](liste); // tri par nom puis prénom
for (Etudiant e : liste) {
[Link](e);
}
}
}
Exercice 2 — TreeSet trié par taille
Mettre les étudiants dans un ensemble trié par taille (du plus petit au plus grand) grâce à un
📝 Comparator.
public class Exo2 {
public static void main(String[] args) {
// TreeSet avec Comparator : tri par taille croissante
Set<Etudiant> ensemble = new TreeSet<>(
[Link](Etudiant::getTaille)
);
[Link](new Etudiant("Martin", "Alice", 1.65));
[Link](new Etudiant("Bernard", "Bob", 1.80));
[Link](new Etudiant("Martin", "Charlie",1.72));
[Link]("Etudiants triés par taille :");
for (Etudiant e : ensemble) {
[Link](e);
}
}
}
// Sortie attendue :
// Martin Alice (1.65m)
// Martin Charlie (1.72m)
// Bernard Bob (1.80m)
Résumé — Choisir la bonne collection
Besoin Collection recommandée
Liste ordonnée avec doublons ArrayList / LinkedList
Ensemble sans doublons HashSet
Ensemble trié automatiquement TreeSet
Association clé → valeur HashMap / TreeMap
Parcours avant/arrière LinkedList + ListIterator