Collections Java : Listes, Ensembles et Mappes
(Explication détaillée)
Ce document explore les Listes, Ensembles et Mappes dans les collections Java, en
fournissant des explications et des cas d'utilisation :
1. Listes (Séquences ordonnées):
Imaginez une liste de courses ou une liste de tâches. Ce sont des séquences
ordonnées où l'ordre des éléments est important. Les Listes en Java proposent des
fonctionnalités similaires :
Types de Listes:
o ArrayList : Stocke les éléments dans un tableau redimensionnable. Idéal
pour l'accès aléatoire (récupérer un élément par sa position) car vous
pouvez sauter directement à l'index.
o LinkedList : Stocke les éléments dans une liste chaînée où chaque
élément pointe vers l'élément suivant et l'élément précédent. Parfait pour
les insertions et suppressions fréquentes au début ou à la fin de la liste.
Cas d'utilisation:
o Listes de courses : Suivre les articles à acheter dans l'ordre où vous les
rencontrerez au magasin (en utilisant ArrayList).
o Listes de tâches : Maintenir les tâches dans l'ordre où elles doivent être
accomplies (en utilisant ArrayList).
o Traiter une séquence d'étapes dans une recette (en utilisant ArrayList).
2. Ensembles (Collections non ordonnées):
Pensez à un sac de bonbons uniques. Peu importe l'ordre dans lequel vous les sortez,
vous ne voulez qu'un seul de chaque parfum. Les Ensembles en Java fonctionnent de
manière similaire :
Caractéristique principale: Aucun doublon autorisé.
Type d'Ensemble:
o HashSet : Utilise une table de hachage pour des recherches rapides
(vérifier si un élément existe). C'est comme avoir une boîte magique qui
vous indique instantanément si un bonbon spécifique est dans le sac.
o TreeSet: Si vous avez besoin d'une collection triée et que vous souhaitez
effectuer des opérations basées sur des plages, utilisez TreeSet.
Cas d'utilisation:
o Stocker des identifiants d'utilisateur uniques : Garantir qu'aucun compte
dupliqué n'existe (en utilisant HashSet).
o Suivi des mots uniques dans un texte : Identifier les mots distincts utilisés
dans un document (en utilisant HashSet).
o Filtrer les entrées dupliquées dans une liste (en utilisant HashSet).
3. Mappes (Paires clé-valeur):
Imaginez un annuaire téléphonique, où chaque nom (clé) est associé à un numéro de
téléphone (valeur). Les Mappes en Java fonctionnent de la même manière :
Structure: Paires clé-valeur. Chaque clé est unique et identifie une valeur
correspondante.
Types de Mappes:
o HashMap : Utilise une table de hachage pour des recherches efficaces par
clé. C'est comme avoir un annuaire téléphonique ultra-rapide qui vous
donne instantanément le numéro lorsque vous fournissez le nom.
o TreeMap : Maintient les clés dans un ordre trié, permettant des opérations
telles que la recherche de la première ou de la dernière clé (utile pour les
dictionnaires triés).
Cas d'utilisation:
o Annuaire téléphonique : Stocker les noms (clés) et les numéros de
téléphone (valeurs) pour un accès facile (en utilisant HashMap).
o Préférences utilisateur : Suivre la langue préférée d'un utilisateur (clé) et
le thème choisi (valeur) (en utilisant HashMap).
o Gestion des stocks : Stocker les identifiants de produits (clés) et leurs
quantités de stock correspondantes (valeurs) (en utilisant HashMap).
Choisir la bonne collection:
Séquences ordonnées avec accès aléatoire : Utilisez ArrayList.
Insertions/suppressions fréquentes au début/à la fin : Utilisez LinkedList.
Collections non ordonnées pour des vérifications rapides d'existence
d'éléments : Utilisez HashSet.
Ensembles triés pour maintenir l'ordre ou effectuer des recherches par plage :
Utilisez TreeSet.
Mappes non ordonnés pour des recherches efficaces par clé : Utilisez HashMap.
Mappes triés pour maintenir l'ordre dans les paires clé-valeur : Utilisez TreeMap.
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
public class ComprehensiveCollectionExample {
public static void main(String[] args) {
// **1. Listes (Séquences ordonnées)**
// **1.1 ArrayList (Accès aléatoire efficace)**
// Liste de courses pour illustrer ArrayList
ArrayList<String> shoppingList = new ArrayList<>();
shoppingList.add("Lait");
shoppingList.add("Oeufs");
shoppingList.add("Pain");
// Accès à un élément par son index (position)
String firstItem = shoppingList.get(0);
System.out.println("Premier élément de la liste de courses (ArrayList): " + firstItem);
// Insérer un élément à un index spécifique (en maintenant l'ordre)
shoppingList.add(1, "Fromage");
System.out.println("Liste de courses mise à jour (ArrayList, add(index, element)): " + shoppingList);
// Supprimer un élément par sa valeur
shoppingList.remove("Oeufs");
System.out.println("Liste de courses après la suppression de 'Oeufs' (ArrayList): " + shoppingList);
// **1.2 LinkedList (Insertions/Suppressions en début/fin efficaces)**
// Liste de lecture musicale pour illustrer LinkedList
LinkedList<String> playlist = new LinkedList<>();
playlist.addFirst("Bohemian Rhapsody");
playlist.addLast("Imagine");
// Insérer un morceau après le premier morceau
playlist.add(1, "Hey Jude");
System.out.println("Playlist mise à jour (LinkedList, add(index, element)): " + playlist);
// Supprimer un élément par sa valeur
playlist.remove("Imagine");
System.out.println("Playlist après la suppression de 'Imagine' (LinkedList): " + playlist);
// **2. Ensembles (Collections non ordonnées)**
// **2.1 HashSet (Recherches rapides, pas d'ordre)**
// Ensemble d'identifiants d'utilisateurs pour illustrer HashSet
HashSet<Integer> userIDs = new HashSet<>();
userIDs.add(12345);
userIDs.add(67890);
userIDs.add(12345); // Dupliqué ignoré
// Vérifier si un identifiant d'utilisateur spécifique existe
boolean userIDExists = userIDs.contains(45678);
System.out.println("Identifiant utilisateur 45678 présent (HashSet): " + userIDExists);
// Itérer sur les éléments de l'ensemble (pas d'ordre garanti)
Iterator<Integer> userIDIterator = userIDs.iterator();
System.out.print("Identifiants utilisateurs (HashSet): ");
while (userIDIterator.hasNext()) {
System.out.print(userIDIterator.next() + " ");
System.out.println();
// **2.2 TreeSet (Recherches rapides, ordre trié)**
// Ensemble de mots uniques pour illustrer TreeSet
TreeSet<String> uniqueWords = new TreeSet<>();
uniqueWords.add("Hello");
uniqueWords.add("world");
uniqueWords.add("and");
uniqueWords.add("welcome");
// Itérer sur les éléments dans l'ordre trié (alphabétique)
System.out.print("Mots uniques triés (TreeSet): ");
for (String word : uniqueWords) {
System.out.print(word + " ");
System.out.println();
// Obtenir le premier et le dernier mot (ordre trié)
String firstWord = uniqueWords.first();
String lastWord = uniqueWords.last();
System.out.println("Premier mot (TreeSet): " + firstWord);
System.out.println("Dernier mot (TreeSet): " + lastWord);
// Sous-ensemble (plage de valeurs)
Set<String> subSet = uniqueWords.subSet("and", "welcome");
System.out.println("Sous-ensemble de mots (TreeSet): " + subSet);
// **3. Mappes (Paires clé-valeur)**
// **3.1 HashMap (Recherches par clé efficaces, pas d'ordre)**
// Annuaire téléphonique pour illustrer HashMap
HashMap<String, String> phonebook = new HashMap<>();
phonebook.put("Alice", "123-456-7890");
phonebook.put("Bob", "987-654-3210");
// Récupérer un numéro de téléphone par nom (clé)
String bobsNumber = phonebook.get("Bob");
System.out.println("Numéro de téléphone de Bob (HashMap): " + bobsNumber);
// Vérifier si une entrée spécifique existe (par clé)
boolean aliceExists = phonebook.containsKey("Alice");
System.out.println("Est-ce qu'Alice est dans l'annuaire (HashMap): " + aliceExists);
// Supprimer une entrée par clé
phonebook.remove("Bob");
System.out.println("Annuaire après suppression de Bob (HashMap): " + phonebook);
// **3.2 TreeMap (Recherches par clé efficaces, ordre trié)**
// Stock pour illustrer TreeMap
TreeMap<String, Integer> inventory = new TreeMap<>();
inventory.put("T-Shirt", 10);
inventory.put("Sweat", 5);
inventory.put("Casquette", 15);
// Obtenir la première et la dernière entrée (ordre trié par clé)
Map.Entry<String, Integer> firstItem = inventory.firstEntry();
Map.Entry<String, Integer> lastItem = inventory.lastEntry();
System.out.println("Premier article en stock (TreeMap): " + firstItem.getKey() + " (" + firstItem.getValue() +
")");
System.out.println("Dernier article en stock (TreeMap): " + lastItem.getKey() + " (" + lastItem.getValue() +
")");
}
Parcours :
import java.util.ArrayList;
import java.util.Iterator;
public class IterationExample {
public static void main(String[] args) {
// Sample ArrayList of numbers
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
// **1. Normal for loop (clear and concise for simple iteration)**
System.out.println("Numbers (normal for loop):");
for (int i = 0; i < numbers.size(); i++) {
System.out.println(numbers.get(i));
}
// **2. Enhanced for loop (Java 5+, concise for iterating over
elements)**
System.out.println("\nNumbers (enhanced for loop):");
for (int number : numbers) {
System.out.println(number);
}
// **3. Iterator (flexible iteration with more control)**
System.out.println("\nNumbers (using iterator):");
Iterator<Integer> numberIterator = numbers.iterator();
while (numberIterator.hasNext()) {
System.out.println(numberIterator.next());
}
}
}
Comparaison (Pour le Trie) :
Lorsque on doit trier des objets, on utilise deux approches principales : la méthode
compareTo et la classe Comparator. Voici quand les utiliser :
Utiliser la méthode compareTo quand :
On veut définir un ordre naturel pour la classe elle-même. Cet ordre s'applique
automatiquement lors de l'utilisation de méthodes de tri
comme Collections.sort ou TreeSet.
La logique de comparaison est simple et directement liée aux attributs de l'objet.
On compare uniquement des objets de la même classe.
Utiliser une classe Comparator séparée (et sa méthode compare) quand :
On a besoin de plusieurs critères de tri pour la même classe. On peut définir
plusieurs classes Comparator pour différents besoins de tri. = > benesba lina
a7na most of the time hedha 3leh nesta3mlouha el method 2 , kif
yabdew 3ana barcha triet, ya3ni bch naamlo trie bel nom, w
mba3ed tri ekhor bel Moyenne (chouf example el code) …
La logique de comparaison est complexe et implique plusieurs attributs ou
calculs.
On veut comparer des objets de classes différentes partageant une logique de
comparaison commune.
Methode 1 ⬇️⬇️:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
class Etudiant implements Comparable<Etudiant> {
private int matricule;
private String nom;
private String prenom;
public Etudiant(int matricule, String nom, String prenom) {
this.matricule = matricule;
this.nom = nom;
this.prenom = prenom;
}
public int getMatricule() {
return matricule;
}
public String getNom() {
return nom;
}
public String getPrenom() {
return prenom;
}
@Override
public int compareTo(Etudiant autreEtudiant) {
// Tri par matricule croissant
return Integer.compare(this.matricule, autreEtudiant.matricule);
}
@Override
public String toString() {
return "Etudiant{" +
"matricule=" + matricule +
", nom='" + nom + '\'' +
", prenom='" + prenom + '\'' +
'}';
}
}
public class Main {
public static void main(String[] args) {
// Liste d'étudiants non triée
ArrayList<Etudiant> etudiants = new ArrayList<>();
etudiants.add(new Etudiant(1234, "Dupont", "Jean"));
etudiants.add(new Etudiant(5678, "Martin", "Pierre"));
etudiants.add(new Etudiant(9012, "Durant", "Marie"));
System.out.println("Liste d'étudiants non triée : ");
for (Etudiant etudiant : etudiants) {
System.out.println(etudiant);
}
// Tri de la liste par matricule croissant
Collections.sort(etudiants);
System.out.println("\nListe d'étudiants triée par matricule : ");
for (Etudiant etudiant : etudiants) {
System.out.println(etudiant);
}
}
}
Method 2 :
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
class Etudiant {
private int matricule;
private String nom;
private String prenom;
public Etudiant(int matricule, String nom, String prenom) {
this.matricule = matricule;
this.nom = nom;
this.prenom = prenom;
}
public int getMatricule() {
return matricule;
}
public String getNom() {
return nom;
}
public String getPrenom() {
return prenom;
}
public double getMoyenne() {
// Replace 0.0 with the actual calculation of the average grade based on
student's notes
return 0.0;
}
@Override
public int compareTo(Etudiant autreEtudiant) {
// Tri par matricule croissant
return Integer.compare(this.matricule, autreEtudiant.matricule);
}
@Override
public String toString() {
return "Etudiant{" +
"matricule=" + matricule +
", nom='" + nom + '\'' +
", prenom='" + prenom + '\'' +
'}';
}
}
class CompareMoyenne implements Comparator<Etudiant> {
@Override
public int compare(Etudiant etudiant1, Etudiant etudiant2) {
// Tri par moyenne décroissante (la plus élevée d'abord)
return Double.compare(etudiant2.getMoyenne(), etudiant1.getMoyenne());
}
}
class CompareNom implements Comparator<Etudiant> {
@Override
public int compare(Etudiant etudiant1, Etudiant etudiant2) {
// Tri par nom croissant (ordre alphabétique)
return etudiant1.getNom().compareTo(etudiant2.getNom());
}
}
public class Main {
public static void main(String[] args) {
// Liste d'étudiants (déjà triée par matricule grâce à
Etudiant.compareTo)
ArrayList<Etudiant> etudiants = new ArrayList<>();
etudiants.add(new Etudiant(1234, "Dupont", "Jean"));
etudiants.add(new Etudiant(5678, "Martin", "Pierre"));
etudiants.add(new Etudiant(9012, "Durant", "Marie"));
System.out.println("Liste d'étudiants non triée (déjà triée par
matricule) : ");
for (Etudiant etudiant : etudiants) {
System.out.println(etudiant);
}
// Tri par moyenne décroissante (démonstration explicite)
ArrayList<Etudiant> copiedListForAvgSort = new ArrayList<>(etudiants);
// Create a copy to avoid modifying the original list
Collections.sort(copiedListForAvgSort, new CompareMoyenne());
System.out.println("\nListe d'étudiants triée par moyenne décroissante :
");
for (Etudiant etudiant : copiedListForAvgSort) {
System.out.println(etudiant);
}
// Tri par nom croissant
Collections.sort(etudiants, new CompareNom()); // Sort the original list
by name
System.out.println("\nListe d'étudiants triée par nom croissant : ");
for (Etudiant etudiant : etudiants) {
System.out.println(etudiant);
}
}
}
