Exercices sur les Collections, les Exceptions et les Comparateurs

---

Exercice 1 — Collections simples

Objectifs

• Manipuler ArrayList, LinkedHashSet, HashMap
• Utiliser un Iterator pour supprimer des éléments en toute sécurité

Énoncé

À partir de la liste :

List<String> noms = List.of("Alice","Bob","Alice","Charles","Bob","David","Alice");

1. Copiez-la dans une ArrayList modifiable. 2. Supprimez en place tous les noms dont la longueur est < 4 via un iterator. 3. Créez un LinkedHashSet à partir de la liste filtrée pour dédupliquer sans perdre l’ordre. 4. Construisez une HashMap<String,Integer> qui contient la fréquence des prénoms dans la liste initiale (utilisez merge).

💻 Squelette de code

List<String> source = List.of("Alice","Bob","Alice","Charles","Bob","David","Alice");
List<String> modifiable = new ArrayList<>(source);

// b) suppression via iterator
Iterator<String> it = modifiable.iterator();
// TODO: remove if length < 4

Set<String> uniques = new LinkedHashSet<>(modifiable);

Map<String,Integer> freq = new HashMap<>();
for (String s : source) {
    // TODO: freq.merge(...)
}

System.out.println("Liste filtrée  : " + modifiable);
System.out.println("Uniques (ordre): " + uniques);
System.out.println("Fréquences     : " + freq);

---

Exercice 2 — Collections + Exceptions personnalisées

Objectifs

• Concevoir une petite classe RegistreEtudiants
• Gérer les erreurs à l’aide d’exceptions personnalisées
• Utiliser une Map pour gérer les étudiants

Énoncé

Vous gérez un registre d’étudiants : clé = DA (String), valeur = Étudiant.

1. Créez class Etudiant { String da, String nom; double moyenne; }
2. Créez deux exceptions :
   • DuplicateStudentException (ajout d’un DA déjà présent)
   • StudentNotFoundException (DA introuvable à la recherche ou suppression)
3. Implémentez une classe RegistreEtudiants avec :
   • void ajouter(Etudiant e) → lève DuplicateStudentException
   • Etudiant chercher(String da) → lève StudentNotFoundException
   • void supprimer(String da) → lève StudentNotFoundException
   • Collection<Etudiant> tous()
4. Écrivez un main qui teste les cas d’erreur avec try/catch et affiche les messages.

Squelette de code

class DuplicateStudentException extends Exception {
    public DuplicateStudentException(String msg) { super(msg); }
}
class StudentNotFoundException extends Exception {
    public StudentNotFoundException(String msg) { super(msg); }
}

class Etudiant {
    String da, nom;
    double moyenne;
    // ctor, getters, toString...
}

class RegistreEtudiants {
    private final Map<String, Etudiant> parDa = new HashMap<>();

    public void ajouter(Etudiant e) throws DuplicateStudentException {
        // TODO
    }
    public Etudiant chercher(String da) throws StudentNotFoundException {
        // TODO
        return null;
    }
    public void supprimer(String da) throws StudentNotFoundException {
        // TODO
    }
    public Collection<Etudiant> tous() { return parDa.values(); }
}

public class Main {
    public static void main(String[] args) {
        var reg = new RegistreEtudiants();
        // TODO: ajouter, tester doublon, tester suppression
    }
}

---

Exercice 3 — Collections + Comparator

Objectifs

• Créer plusieurs comparateurs
• Trier des collections avec des critères multiples
• Utiliser un TreeSet avec un Comparator

Énoncé

On veut gérer une bibliothèque de livres.

1. Créez la classe Livre { String titre; String auteur; int pages; int annee; }.
2. Créez les comparateurs suivants :
   • Comparator<Livre> parAuteurPuisTitre
   • Comparator<Livre> parAnneeDescPuisPagesDesc
3. Triez une List<Livre> selon chacun de ces comparateurs.
4. Créez un TreeSet<Livre> basé sur parAuteurPuisTitre et observez les doublons.

Squelette de code

class Livre {
    String titre, auteur;
    int pages, annee;
    // ctor, getters, toString...
}

Comparator<Livre> parAuteurPuisTitre = //TODO

Comparator<Livre> parAnneeDescPuisPagesDesc = //TODO

List<Livre> bib = new ArrayList<>(List.of(
    new Livre("Java", "Dupont", 450, 2020),
    new Livre("Algo", "Armand", 300, 2018),
    new Livre("Structures", "Dupont", 500, 2020),
    new Livre("POO", "Zola", 280, 2016)
));

bib.sort(parAuteurPuisTitre);
System.out.println("Auteur→Titre : " + bib);

bib.sort(parAnneeDescPuisPagesDesc);
System.out.println("Année↓ puis Pages↓ : " + bib);

Set<Livre> triAuteurTitre = new TreeSet<>(parAuteurPuisTitre);
triAuteurTitre.addAll(bib);
System.out.println("TreeSet (Auteur→Titre) : " + triAuteurTitre);

💡 Réflexion : Pourquoi certains livres ne sont pas ajoutés au TreeSet ?

---

Exercice 4 — Collections + compareTo() (ordre naturel)

Objectifs

• Implémenter Comparable
• Définir un ordre naturel multi-critères
• Utiliser Collections.sort et TreeSet

Énoncé

Vous gérez des tâches de projet.

1. Créez class Tache implements Comparable<Tache> { String id; int priorite; LocalDate echeance; }.
2. L’ordre naturel doit être :
   • par priorité croissante (1 = plus urgent)
   • puis par échéance la plus proche
   • puis par id alphabétique
3. Triez une List<Tache> avec Collections.sort().
4. Placez ces tâches dans un TreeSet<Tache> et observez les doublons.

Squelette de code

class Tache implements Comparable<Tache> {
    String id;
    int priorite;
    LocalDate echeance;

    @Override
    public int compareTo(Tache o) {
       //TODO
    }
}

public class Main {
    public static void main(String[] args) {
        List<Tache> backlog = new ArrayList<>(List.of(
            new Tache("A12", 2, LocalDate.of(2025,11,10)),
            new Tache("B07", 1, LocalDate.of(2025,11,15)),
            new Tache("A11", 1, LocalDate.of(2025,11,10)),
            new Tache("C01", 3, LocalDate.of(2025,11,05))
        ));

        Collections.sort(backlog);
        System.out.println("Ordre naturel : " + backlog);

        Set<Tache> triNaturel = new TreeSet<>(backlog);
        System.out.println("TreeSet (ordre naturel) : " + triNaturel);
    }
}

---

💡 Réflexion

• Que se passe-t-il si compareTo() retourne 0 mais que equals() est false ?
  → Les TreeSet et TreeMap considéreront les objets comme égaux pour le tri.
• Pensez à cohérence entre equals et compareTo si vos classes sont stockées dans plusieurs types de collections.

---