Cours Complet sur les Collections en Java :

Hiérarchie, Complexités, Constitution Interne,

Fonctionnement, et Exemples Pratiques

Introduction
Les collections en Java sont des structures de données permettant de stocker et de manipuler
des groupes d'objets de manière efficace. Ce cours fournit un aperçu détaillé des collections, de
leur hiérarchie, des complexités, de la constitution interne, ainsi que du fonctionnement
spécifique des méthodes equals et hashCode , des interfaces Comparable et Comparator , et
des différentes méthodes de lecture des données dans les collections.

1. Hiérarchie des Collections en Java

Le framework des collections en Java comprend plusieurs interfaces de base, chacune ayant des
implémentations spécifiques.

1.1 Interfaces Principales

1. Collection: Interface de base pour toutes les collections. Elle regroupe des sous-
interfaces comme List , Set , et Queue .
2. List: Une List est une collection ordonnée qui permet les éléments en double. Les
éléments peuvent être accessibles par leur index.
• Implémentations:
◦ ArrayList
◦ LinkedList
◦ Vector
3. Set: Un Set est une collection qui ne permet pas les éléments en double. Il n'est
pas nécessairement ordonné.
• Implémentations:
◦ HashSet
◦ LinkedHashSet
◦ TreeSet
 4. Queue: Une Queue est une collection destinée à contenir des éléments avant leur
traitement. Elle suit en général le principe FIFO (First-In-First-Out).
• Implémentations:
◦ PriorityQueue
◦ ArrayDeque
5. Map: Une Map est une collection qui associe des clés uniques à des valeurs. Bien
qu'elle ne fasse pas partie de l'interface Collection , elle est souvent traitée dans
le contexte des collections.
• Implémentations:
◦ HashMap
◦ LinkedHashMap
◦ TreeMap
◦ Hashtable

1.2 Diagramme de la Hiérarchie

Voici une représentation simplifiée de la hiérarchie des collections en Java :

Collection
/ | \
/ | \
List Set Queue
/ \ | |
ArrayList HashSet LinkedList
LinkedList TreeSet PriorityQueue

2. Constitution Interne, Complexités et Exemples

des Collections

2.1 ArrayList
• Structure Interne: Tableau dynamique.
• Principe: Un ArrayList est basé sur un tableau redimensionnable. Lorsque le
 tableau est plein, sa taille est doublée pour accueillir plus d'éléments.
• Complexités:
◦ Accès (get): O(1) - Accès direct à l'élément via son index.
◦ Ajout (add): O(1) en moyenne, O(n) dans le pire des cas (lors du
redimensionnement).
◦ Suppression (remove): O(n) - Tous les éléments après l'élément
supprimé doivent être décalés.
• Usage Pratique:
◦ Quand utiliser ArrayList : Utilisez un ArrayList lorsque vous avez
besoin d'une collection dynamique d'éléments où les opérations d'accès
et de mise à jour sont fréquentes. Par exemple, dans un programme de
gestion d'inventaire où vous ajoutez et modifiez souvent des articles.
• Exemple d'utilisation:
import java.util.ArrayList;
import java.util.Collections;

public class ArrayListExample {

public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");
System.out.println("ArrayList: " + list);

// Tri de la liste
Collections.sort(list);
System.out.println("Sorted ArrayList: " + list);

list.remove("Python");
System.out.println("After removal: " + list);

// Lecture des données avec différentes boucles

System.out.println("Using for-each loop:");
for (String lang : list) {
System.out.println(lang);
}

System.out.println("Using iterator:");
var iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}

• equals et hashCode : Dans une ArrayList , les méthodes equals et hashCode

sont utilisées principalement lorsque vous comparez des objets ou recherchez un
objet spécifique.
• Comparable et Comparator:
◦ Comparable: L'interface Comparable est utilisée pour définir un ordre
naturel pour les objets d'une classe.
◦ Exemple de Comparable :

import java.util.ArrayList;
import java.util.Collections;

public class Person implements Comparable<Person> {

String name;
int age;

public Person(String name, int age) {

this.name = name;
this.age = age;
}

@Override
public int compareTo(Person other) {
return Integer.compare(this.age, other.age); // Tri par âge
}

@Override
public String toString() {
return name + ": " + age;
}

public static void main(String[] args) {

ArrayList<Person> list = new ArrayList<>();
list.add(new Person("Alice", 30));
list.add(new Person("Bob", 25));
list.add(new Person("Charlie", 35));

Collections.sort(list); // Utilisation de compareTo()

System.out.println("Sorted ArrayList by age: " + list);
}
}

◦ Comparator: Si vous souhaitez définir plusieurs manières de trier les

objets, ou si la classe dont vous souhaitez trier les instances ne peut pas
être modifiée pour implémenter Comparable , vous utilisez
Comparator .
◦ Exemple de Comparator :
 import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Person {

String name;
int age;

public Person(String name, int age) {

this.name = name;
this.age = age;
}

@Override
public String toString() {
return name + ": " + age;
}

public static void main(String[] args) {

ArrayList<Person> list = new ArrayList<>();
list.add(new Person("Alice", 30));
list.add(new Person("Bob", 25));
list.add(new Person("Charlie", 35));

// Tri par nom en utilisant Comparator

Collections.sort(list, new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return p1.name.compareTo(p2.name); // Tri par nom
}
});

System.out.println("Sorted ArrayList by name: " + list);

}
}

2.2 LinkedList
• Structure Interne: Liste doublement chaînée.
• Principe: Chaque élément est un nœud contenant une référence au nœud suivant et
précédent.
• Complexités:
◦ Accès (get): O(n) - La liste doit être traversée jusqu'à l'élément
souhaité.
◦ Ajout (add): O(1) pour ajout en tête ou en queue.
◦ Suppression (remove): O(1) si la position est connue, sinon O(n) .
• Usage Pratique:
◦ Quand utiliser LinkedList : Utilisez LinkedList lorsque vous avez
besoin de manipuler fréquemment les éléments au début ou au milieu de
la collection, par exemple dans la gestion d'une file d'attente où les
éléments sont fréquemment ajoutés ou supprimés en début de liste.
• Exemple d'utilisation:
 import java.util.LinkedList;

public class LinkedListExample {

public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("Java");
list.add("Python");
list.add("C++");
System.out.println("LinkedList: " + list);

list.remove("Python");
System.out.println("After removal: " + list);

// Lecture des données avec différentes boucles

System.out.println("Using for-each loop:");
for (String lang : list) {
System.out.println(lang);
}

System.out.println("Using iterator:");
var iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}

• equals et hashCode : Comme pour ArrayList , ces méthodes sont

principalement utilisées pour comparer des objets dans une LinkedList .
• Comparable et Comparator: Les éléments d'une LinkedList peuvent être triés
ou comparés de manière similaire à ceux d'une ArrayList .

2.3 HashSet
• Structure Interne: Table de hachage.
• Principe: Les éléments sont stockés dans des "seaux" en fonction de la valeur de
leur code de hachage. Les éléments dupliqués sont rejetés.
• Complexités:
 ◦ **Ajout (

add)**: O(1) en moyenne, O(n) dans le pire des cas (collision de hachage).

• Suppression (remove): O(1) en moyenne.

• Recherche (contains): O(1) en moyenne.
• Usage Pratique:
◦ Quand utiliser HashSet : Utilisez HashSet lorsque vous avez besoin
d'une collection unique d'éléments et que l'ordre des éléments n'a pas
d'importance. Par exemple, pour maintenir une collection d'identifiants
uniques dans une application.
• Exemple d'utilisation:

import java.util.HashSet;

public class HashSetExample {

public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("Java");
set.add("Python");
set.add("C++");
set.add("Java"); // Duplique, ne sera pas ajouté

System.out.println("HashSet: " + set);

// Lecture des données avec différentes boucles

System.out.println("Using for-each loop:");
for (String lang : set) {
System.out.println(lang);
}

System.out.println("Using iterator:");
var iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
 • equals et hashCode : Ces méthodes sont cruciales pour le fonctionnement d’un
HashSet . Lorsqu'un objet est ajouté à un HashSet , Java utilise d'abord la méthode
hashCode pour déterminer le seau où placer l'objet. Ensuite, la méthode equals
est utilisée pour vérifier si l'objet est déjà présent dans le seau. Il est important de
redéfinir equals et hashCode de manière cohérente.
• Comparable et Comparator: Non applicable directement pour HashSet , car ce
dernier ne maintient pas d'ordre parmi ses éléments.

2.4 TreeSet
• Structure Interne: Arbre rouge-noir (Red-Black Tree).
• Principe: Les éléments sont stockés de manière triée en utilisant un arbre auto-
équilibré.
• Complexités:
◦ Ajout (add): O(log n)
◦ Suppression (remove): O(log n)
◦ Recherche (contains): O(log n)
• Usage Pratique:
◦ Quand utiliser TreeSet : Utilisez TreeSet lorsque vous avez besoin
d'une collection unique d'éléments triés. Par exemple, pour stocker des
enregistrements de transactions classées par date.
• Exemple d'utilisation:
 import java.util.TreeSet;

public class TreeSetExample {

public static void main(String[] args) {
TreeSet<String> set = new TreeSet<>();
set.add("Java");
set.add("Python");
set.add("C++");
set.add("Java"); // Duplique, ne sera pas ajouté

System.out.println("TreeSet (sorted): " + set);

// Lecture des données avec différentes boucles

System.out.println("Using for-each loop:");
for (String lang : set) {
System.out.println(lang);
}

System.out.println("Using iterator:");
var iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}

• equals et hashCode : Ces méthodes ne sont pas utilisées dans TreeSet pour la
comparaison des éléments. TreeSet se base sur compareTo (de l'interface
Comparable ) ou sur un Comparator pour ordonner les éléments.
• Comparable et Comparator:
◦ Comparable: Les objets dans un TreeSet doivent implémenter
Comparable s’ils doivent être triés par leur ordre naturel.
◦ Comparator: Si un ordre spécifique est requis, un Comparator peut
être utilisé pour créer le TreeSet .

2.5 HashMap
• Structure Interne: Table de hachage.
• Principe: Les paires clé-valeur sont stockées dans des seaux en fonction du
hachage de la clé. Lorsque plusieurs clés ont le même hachage (collision), les
valeurs sont stockées dans une liste chaînée ou dans un arbre binaire si la liste
devient trop longue.
• Complexités:
◦ Ajout (put): O(1) en moyenne, O(n) dans le pire des cas.
◦ Suppression (remove): O(1) en moyenne.
◦ Recherche (get): O(1) en moyenne.
• Usage Pratique:
◦ Quand utiliser HashMap : Utilisez HashMap lorsque vous avez besoin
de stocker des paires clé-valeur avec un accès rapide à la valeur basée
sur une clé. Par exemple, pour stocker des configurations où les noms
des paramètres sont les clés et les valeurs des paramètres sont les
valeurs.
• Exemple d'utilisation:
import java.util.HashMap;

public class HashMapExample {

public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("One", 1);
map.put("Two", 2);
map.put("Three", 3);

System.out.println("HashMap: " + map);

System.out.println("Value for key 'Two': " + map.get("Two"));

// Lecture des données avec différentes boucles

System.out.println("Using for-each loop on keys:");
for (String key : map.keySet()) {
System.out.println(key + ": " + map.get(key));
}

System.out.println("Using iterator on entries:");

var iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
var entry = iterator.next();
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}

• equals et hashCode : Les méthodes equals et hashCode sont fondamentales

pour le fonctionnement d’un HashMap . Lorsqu'une clé est ajoutée à un HashMap ,
Java utilise hashCode pour déterminer le seau dans lequel la clé sera placée. Si
plusieurs clés ont le même hash code (collision), equals est utilisée pour
différencier les clés. Il est crucial de redéfinir ces méthodes pour assurer que les
objets stockés dans une HashMap fonctionnent correctement.
• Complexité dégradée: La complexité de HashMap peut devenir O(n) si de
nombreuses clés génèrent le même hash code, ce qui provoquerait des collisions
fréquentes et entraînerait l'utilisation de listes chaînées longues ou d'arbres pour
gérer les collisions.
2.6 TreeMap
• Structure Interne: Arbre rouge-noir.
• Principe: Les paires clé-valeur sont stockées dans un ordre trié.
• Complexités:
◦ Ajout (put): O(log n)
◦ Suppression (remove): O(log n)
◦ Recherche (get): O(log n)
• Usage Pratique:
◦ Quand utiliser TreeMap : Utilisez TreeMap lorsque vous avez besoin
de stocker des paires clé-valeur triées par clé. Par exemple, pour gérer
des dictionnaires où les clés doivent être ordonnées alphabétiquement.
• Exemple d'utilisation:
import java.util.TreeMap;

public class TreeMapExample {

public static void main(String[] args) {
TreeMap<String, Integer> map = new TreeMap<>();
map.put("One", 1);
map.put("Two", 2);
map.put("Three", 3);

System.out.println("TreeMap (sorted): " + map);

System.out.println("Value for key 'Two': " + map.get("Two"));

// Lecture des données avec différentes boucles

System.out.println("Using for-each loop on keys:");
for (String key : map.keySet()) {
System.out.println(key + ": " + map.get(key));
}

System.out.println("Using iterator on entries:");

var iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
var entry = iterator.next();
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}

• equals et hashCode : Contrairement à HashMap , TreeMap ne repose pas sur

hashCode . Au lieu de cela, il se base sur compareTo ou sur un Comparator fourni
pour ordonner les clés.
• Comparable et Comparator:
◦ Comparable: Les clés dans un TreeMap doivent implémenter
Comparable s'il n'y a pas de Comparator fourni.
◦ Comparator: Si un ordre spécifique des clés est requis, un
Comparator peut être utilisé pour créer le TreeMap .
3. Comparaison des Collections
| Collection | Structure interne | Accès (get) | Ajout (add/put) | Suppression (remove) | equals et
hashCode | Comparable et Comparator |
|---------------|-----------------------|-------------|-----------------|

----------------------|--------------------------|--------------------------------|
| ArrayList | Tableau dynamique | O(1) | O(1) ou O(n) | O(n) | Utilisé pour comparaison |
Utilisés pour tri |
| LinkedList | Liste doublement chaînée | O(n) | O(1) | O(1) ou O(n) | Utilisé pour
comparaison | Utilisés pour tri |
| HashSet | Table de hachage | O(1) | O(1) | O(1) | Essentiel pour le fonctionnement | Non
applicable |
| TreeSet | Arbre rouge-noir | O(log n) | O(log n) | O(log n) | Non utilisé | Essentiel pour le
fonctionnement |
| HashMap | Table de hachage | O(1) | O(1) | O(1) | Essentiel pour le fonctionnement | Non
applicable |
| TreeMap | Arbre rouge-noir | O(log n) | O(log n) | O(log n) | Non utilisé | Essentiel pour
le fonctionnement |

4. Choisir la Bonne Collection

• Si vous avez besoin d'accès rapide par index et que vous ne faites pas
souvent de suppression/ajout au milieu de la collection, ArrayList est un
bon choix.
• Si vous avez besoin d'ajout/suppression fréquents au début ou au milieu de
la collection, LinkedList est préférable.
• Si vous avez besoin d'une collection sans doublons avec accès rapide,
utilisez HashSet .
• Si vous avez besoin d'une collection triée sans doublons, TreeSet est idéal.
• Si vous avez besoin de stocker des paires clé-valeur avec un accès rapide,
HashMap est approprié.
• Si vous avez besoin de stocker des paires clé-valeur triées, utilisez TreeMap .
Ce cours vous donne une compréhension approfondie des collections en Java, en mettant en
lumière leur fonctionnement interne, leur hiérarchie, leur complexité, ainsi que l'importance des
méthodes equals , hashCode , Comparable , et Comparator dans leur utilisation. Cela devrait
vous permettre de choisir la collection la plus appropriée en fonction de vos besoins spécifiques
en développement Java.