Les conteneurs en Java permettent de stocker et manipuler des colllections d'objets. Ils sont principalement représentés par des interfaces comme List, Set, Queue et Map, chacune avec plusieurs implémentations aux caractéristiques distinctes.

List : ArrayList vs LinkedList

L'interface List représente une séquence ordonnée d'éléments permettant des doublons. Deux implémentations courantes sont ArrayList et LinkedList.

• ArrayList offre un accès aléatoire rapide grâce à son support par tableau. Les insertions et suppressions au milieu de la liste sont coûteuses car elles nécessitent de décaler les éléments.
• LinkedList fournit un ajout et une suppression efficaces à n'importe quelle position, car il s'agit d'une structure en liste chaînée. Cependant, l'accès aux éléments par index est plus lent.

Le choix dépend de l'usage prédominant : privilégiez ArrayList pour les lectures fréquentes par index et LinkedList pour les modifications structurelles fréquentes.

Set : unicité et ordre

L'interface Set garantit l'unicité des éléments. Ses implémentations diffèrent par la gestion de l'ordre et les performances.

import java.util.*;

public class DemonstrationSet {
    public static void main(String[] args) {
        Set<String> ensemble = new LinkedHashSet<>();
        ensemble.add("Alpha");
        ensemble.add("Beta");
        ensemble.add("Gamma");
        ensemble.add("Beta"); // Doublon, ne sera pas ajouté
        System.out.println("LinkedHashSet : " + ensemble);

        Set<String> ensembleTrie = new TreeSet<>(ensemble);
        System.out.println("TreeSet : " + ensembleTrie);
    }
}

HashSet offre les meilleures performances en recherche, mais sans garantie d'ordre. TreeSet maintient les éléments triés selon leur ordre naturel ou un Comparator. LinkedHashSet conserve l'ordre d'insertion tout en ayant des performances proches de HashSet.

Stack et Queue

Stack (pile) suit le princpie LIFO (Last-In-First-Out). Bien que java.util.Stack existe, il est souvent préférable d'utiliser un Deque (double-ended queue) comme ArrayDeque pour simuler une pile.

import java.util.ArrayDeque;
import java.util.Deque;

public class PileDeDemo {
    private Deque<String> stockage = new ArrayDeque<>();

    public void empiler(String element) {
        stockage.push(element);
    }

    public String depiler() {
        return stockage.pop();
    }

    public String sommet() {
        return stockage.peek();
    }
}

Queue (file) suit le principe FIFO (First-In-First-Out). LinkedList implémente l'interface Queue et Deque. Les méthodes principales sont offer (ajout), poll (retrait et retour) et peek (consultation sans retrait).

import java.util.LinkedList;
import java.util.Queue;

public class FileDeDemo {
    public static void main(String[] args) {
        Queue<Integer> file = new LinkedList<>();
        file.offer(10);
        file.offer(20);
        file.offer(15);
        
        while (!file.isEmpty()) {
            System.out.print(file.poll() + " ");
        }
        // Affiche : 10 20 15
    }
}

La PriorityQueue ordonne les éléments selon leur priorité (ordre naturel ou Comparator) et non selon leur ordre d'insertion. L'élément de plus haute priorité est retiré en premier.

Map : association clé-valeur

L'interface Map stocke des paires clé-valeur, où les clés sont uniques.

• HashMap offre les performances les plus rapides pour la recherche, sans garantie d'ordre sur les clés.
• TreeMap maintient les clés triées, ce qui le rend légèrement plus lent.
• LinkedHashMap conserve l'ordre d'insertion des clés.

import java.util.HashMap;
import java.util.Map;

public class CarteDeDemo {
    public static void main(String[] args) {
        Map<String, Integer> compteur = new HashMap<>();
        String[] mots = {"un", "deux", "trois", "un", "deux", "trois", "un"};
        
        for (String mot : mots) {
            compteur.put(mot, compteur.getOrDefault(mot, 0) + 1);
        }
        System.out.println(compteur);
    }
}