ArrayList, HashMap, HashSet
Principales collections utilisées en Java
Notions théoriques
Pourquoi les collections ?
Les tableaux ont une limitation majeure : leur taille est fixe. Si vous ne savez pas à l'avance combien d'éléments vous allez stocker, les tableaux ne conviennent pas. Les collections Java sont des structures de données dynamiques qui s'adaptent automatiquement.
Pour les utiliser, on importe le package java.util :
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
// ou tout importer :
import java.util.*;
ArrayList — La liste dynamique
ArrayList<Type> est une liste dont la taille change automatiquement. Le <Type> entre chevrons indique le type des éléments stockés : on parle de generics (nous les étudierons en détail en POO).
import java.util.ArrayList;
ArrayList<String> prenoms = new ArrayList<>();
// Ajouter des éléments
prenoms.add("Alice");
prenoms.add("Bob");
prenoms.add("Charlie");
// Accéder à un élément (indice 0)
String premier = prenoms.get(0);
// Modifier un élément
prenoms.set(1, "Barbara");
// Supprimer un élément
prenoms.remove(2); // par indice
prenoms.remove("Alice"); // par valeur
// Taille
int taille = prenoms.size();
// Vérifier si un élément est présent
boolean present = prenoms.contains("Bob");
// Parcours avec for-each
for (String prenom : prenoms) {
System.out.println(prenom);
}
ArrayList<String> signifie "liste de String". On peut utiliser ArrayList<Integer>, ArrayList<Double>, etc. Note qu'on utilise Integer (avec majuscule) et pas int dans les generics. Ces types "enveloppants" s'appellent des wrapper types.
HashMap — La carte clé-valeur
HashMap<K, V> associe des clés à des valeurs. Chaque clé est unique.
import java.util.HashMap;
HashMap<String, Integer> ages = new HashMap<>();
// Ajouter des associations clé → valeur
ages.put("Alice", 17);
ages.put("Bob", 18);
ages.put("Charlie", 16);
// Obtenir une valeur par sa clé
int ageAlice = ages.get("Alice"); // 17
// Vérifier si une clé existe
boolean existe = ages.containsKey("Bob"); // true
// Obtenir toutes les clés
for (String prenom : ages.keySet()) {
System.out.println(prenom + " a " + ages.get(prenom) + " ans");
}
// Taille
int nb = ages.size();
HashMap ne garantit pas l'ordre d'insertion. Si vous avez besoin d'un ordre préservé, utilisez LinkedHashMap.
HashSet — L'ensemble sans doublons
HashSet<Type> stocke des éléments uniques : si vous essayez d'ajouter un doublon, il est ignoré.
import java.util.HashSet;
HashSet<String> langages = new HashSet<>();
langages.add("Java");
langages.add("PHP");
langages.add("Java"); // ignoré, déjà présent
System.out.println(langages.size()); // 2
System.out.println(langages.contains("PHP")); // true
Choisir la bonne collection
| Besoin | Collection |
|---|---|
| Liste ordonnée avec doublons possibles | ArrayList |
| Association clé → valeur | HashMap |
| Éléments uniques sans ordre | HashSet |
Exemple pratique
import java.util.ArrayList;
import java.util.HashMap;
public class GestionClasse {
public static void main(String[] args) {
// Liste des élèves
ArrayList<String> eleves = new ArrayList<>();
eleves.add("Alice");
eleves.add("Bob");
eleves.add("Charlie");
eleves.add("Diana");
System.out.println("Nombre d'élèves : " + eleves.size());
// Notes par élève
HashMap<String, Double> notes = new HashMap<>();
notes.put("Alice", 15.5);
notes.put("Bob", 12.0);
notes.put("Charlie", 17.5);
notes.put("Diana", 9.5);
// Afficher les notes de tous les élèves
System.out.println("\n=== Relevé de notes ===");
for (String eleve : eleves) {
if (notes.containsKey(eleve)) {
System.out.println(eleve + " : " + notes.get(eleve));
} else {
System.out.println(eleve + " : pas de note");
}
}
// Élèves au-dessus de la moyenne
System.out.println("\n=== Élèves admis ===");
for (String eleve : notes.keySet()) {
if (notes.get(eleve) >= 10.0) {
System.out.println(eleve + " est admis(e)");
}
}
}
}
Pour parcourir toutes les paires clé-valeur d'un HashMap, on peut aussi utiliser map.entrySet() qui donne accès à la fois à la clé et à la valeur dans la boucle.
Test de mémorisation/compréhension
TP pour réfléchir et résoudre des problèmes
Vous allez créer un carnet de contacts simplifié qui stocke des noms et des numéros de téléphone.
Étape 1 — Créer le HashMap des contacts
Crée un HashMap<String, String> pour associer des noms à des numéros de téléphone, et ajoute trois contacts.
Le <> vide à droite du new s'appelle le diamond operator (opérateur diamant). Java infère les types à partir de la déclaration à gauche. Avant Java 7, il fallait écrire new HashMap<String, String>(). Aujourd'hui, new HashMap<>() suffit.
Étape 2 — Rechercher un contact
Écris une méthode statique qui cherche un contact par nom et affiche son numéro, ou un message si introuvable.
Appelez toujours containsKey() avant get() sur un HashMap. Si la clé n'existe pas, get() retourne null, ce qui peut provoquer une NullPointerException si vous essayez d'utiliser la valeur retournée.
Étape 3 — Afficher tous les contacts triés
Affiche tous les contacts en parcourant les clés, après les avoir triées avec Collections.sort().
HashMap ne garantit pas l'ordre. Pour un affichage cohérent, récupère les clés dans une ArrayList, trie-la avec Collections.sort(), puis parcours cette liste triée. Cela évite un affichage dans un ordre imprévisible.