Sturcture hiérarchique des collections Java

Le framework de collections en Java repose sur une hiérarchie d'interfaces, de classes abstraites et de classes concrètes. Les classes concrètes, telles que ArrayList, LinkedList ou HashMap, sont représentées par des cadres pleins. Les classes abstraites, comme AbstractCollection ou AbstractList, utilisent des cadres en pointillés, tandis que les interfaces, notamment Collection, Iterator ou List, sont délimitées par des cadres en tirets.

Une caractéristique essentielle est l'implémentation de l'interface Iterator pour parcourir les éléments. Cette interface propose les méthodes hasNext(), next() et remove(). Son sous-interface ListIterator étend ces fonctionnalités avec add(), previous() et hasPrevious(), permettant une itération bidirectionnelle. Les collections non ordonnées, comme HashSet et HashMap, implémentent généralement Iterator, tandis que les collections ordonnées, telles que ArrayList et LinkedList, privilégient ListIterator.

L'utilisation de classes abstraites simplifie le développement de collections personnalisées. Elles fournissent des implémentations par défaut, réduisant ainsi le travail nécessaire en permettant de surcharger ou d'étendre des méthodes spécifiques.

L'interface Collection

Collection représente une agrégation dynamique d'objets, offrant une extansibilité et des performances optimisées par rapport aux tableaux traditionnels. Ses sous-interfaces principales sont List, Set et Queue.

L'interface List

List autorise les éléments dupliqués et maintient un ordre d'insertion. Parmi ses implémentations courantes figurent ArrayList et Vector. Voici un exemple d'utilisation avec des opérations de base :

package com.example.collections;

import java.util.ArrayList;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        List<String> elements = new ArrayList<>();
        elements.add("Premier");
        elements.add("Second");
        elements.add("Premier");
        
        for (String item : elements) {
            System.out.println(item);
        }
        
        elements.remove(0);
        System.out.println("Après suppression :");
        for (String item : elements) {
            System.out.println(item);
        }
        
        System.out.println("Collection vide ? " + elements.isEmpty());
        System.out.println("Index de Second : " + elements.indexOf("Second"));
        System.out.println("Index de Troisième : " + elements.indexOf("Troisième"));
    }
}

L'exécution affiche les éléments avant et après suppression, ainsi que les résultats des méthodes isEmpty() et indexOf().

L'interface Set

Set interdit les éléments en double et peut assurer un tri. Ses implémentations typiques sont HashSet pour un stockage par hachage et TreeSet pour un ordre naturel. Exemple :

package com.example.collections;

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetDemo {
    public static void main(String[] args) {
        Set<String> ensembleTrie = new TreeSet<>();
        ensembleTrie.add("Delta");
        ensembleTrie.add("Alpha");
        ensembleTrie.add("Gamma");
        ensembleTrie.add("Beta");
        System.out.println(ensembleTrie);
        
        Set<String> ensembleHache = new HashSet<>();
        ensembleHache.add("Delta");
        ensembleHache.add("Alpha");
        ensembleHache.add("Gamma");
        ensembleHache.add("Beta");
        System.out.println(ensembleHache);
    }
}

TreeSet affiche les éléments dans l'ordre alphabétique, tandis que HashSet n'assure aucun ordre prévisible.

L'interface Iterator

Iterator est l'interface standard pour parcourir les collections. Elle définit hasNext(), next() et remove() pour itérer de manière séquentielle. Exemple d'itération avec suppression conditionnelle :

package com.example.collections;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorDemo {
    public static void main(String[] args) {
        List<Integer> nombres = new ArrayList<>();
        nombres.add(5);
        nombres.add(10);
        nombres.add(15);
        nombres.add(20);
        
        Iterator<Integer> it = nombres.iterator();
        while (it.hasNext()) {
            int valeur = it.next();
            if (valeur == 10) {
                it.remove();
            } else {
                System.out.println(valeur);
            }
        }
    }
}

Ce code supprime l'élément 10 et affiche les autres. Toute modification directe de la collection pendant l'itération provoque une ConcurrentModificationException.

L'interface Map

Map stocke des paires clé-valeur, où les clés doivent être uniques. Les implémentations courantes incluent HashMap et Hashtable. Exemple d'utilisation :

package com.example.collections;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo {
    public static void main(String[] args) {
        Map<String, String> annuaire = new HashMap<>();
        annuaire.put("Alice", "0123456789");
        annuaire.put("Bob", "9876543210");
        annuaire.put("Carol", "5551234567");
        
        String numero = annuaire.get("Alice");
        System.out.println("Numéro d'Alice : " + numero);
        
        if (annuaire.containsKey("Bob")) {
            System.out.println("Clé 'Bob' présente");
        }
        
        if (annuaire.containsValue("5551234567")) {
            System.out.println("Valeur '5551234567' trouvée");
        }
        
        Set<String> cles = annuaire.keySet();
        for (String cle : cles) {
            System.out.println(cle);
        }
        
        Collection<String> valeurs = annuaire.values();
        for (String val : valeurs) {
            System.out.println(val);
        }
    }
}

L'exemple illustre la récupération de valeurs, la vérificaiton de clés et de valeurs, ainsi que l'itération sur les ensembles de clés et de valeurs.