Parlez de la hiérarchie des collections en Java.

La hiérarchie des collections en Java est construite autour de deux interfaces racines : Collection et Map. Elle est définie dans le package java.util.

• Collection<E> : Interface racine pour la plupart des collections. Représente un groupe d'éléments. Ne garantit pas l'ordre ni l'unicité des éléments.
  • List<E> : Collection ordonnée (séquence). Les éléments ont un indice défini. Peut contenir des doublons.
    • ArrayList<E> : Implémentation basée sur un tableau. Accès rapide, insertions/suppressions lentes au milieu.
    • LinkedList<E> : Implémentation basée sur une liste chaînée. Accès lent, insertions/suppressions rapides au début/fin.
    • Vector<E> : Classe synchronisée obsolète. Semblable à ArrayList, mais thread-safe (et moins performante).
    • Stack<E> : Classe obsolète étendant Vector, implémente le comportement de pile (LIFO).
  • Set<E> : Collection contenant des éléments uniques.
    • HashSet<E> : Implémentation basée sur une table de hachage. Non ordonnée. Opérations rapides add, remove, contains.
    • LinkedHashSet<E> : Maintient l'ordre d'insertion.
    • SortedSet<E> : Ensemble trié en ordre croissant.
      • TreeSet<E> : Implémentation basée sur un arbre rouge-noir. Garantit un ordre trié.
  • Queue<E> : Collection conçue pour stocker des éléments avant traitement, souvent en ordre FIFO (First-In, First-Out).
    • PriorityQueue<E> : Implémentation d'une file de priorité. Les éléments sont extraits selon leur priorité.
    • Deque<E> : (File à double terminaison) File bidirectionnelle. Supporte les insertions et extractions des deux extrémités.
      • ArrayDeque<E> : Implémentation de Deque basée sur un tableau dynamique. Plus rapide que LinkedList pour une utilisation comme pile ou file.
• Map<K, V> : Objet qui mappe des clés à des valeurs. Les clés sont uniques, les valeurs peuvent se répéter.
  • HashMap<K, V> : Implémentation basée sur une table de hachage. Non ordonnée. Opérations rapides put, get, remove.
  • LinkedHashMap<K, V> : Maintient l'ordre d'insertion ou d'accès.
  • SortedMap<K, V> : Carte triée par clés.
    • TreeMap<K, V> : Implémentation basée sur un arbre rouge-noir. Garantit un ordre trié par clés.
  • Hashtable<K, V> : Classe synchronisée obsolète. Semblable à HashMap, mais thread-safe (et moins performante).

Interfaces principales :

Interface	Description	Ordre	Unicité	Doublons de valeurs
Collection	Groupe d'éléments	+/-	+/-	Oui
List	Collection ordonnée	Oui	Non	Oui
Set	Collection d'éléments uniques	+/-	Oui	Non
Queue	Collection pour traitement (FIFO)	Oui	Non	Oui
Deque	File bidirectionnelle	Oui	Non	Oui
Map	Clé-valeur	+/-	Par clé	Oui
SortedSet	Ensemble trié	Oui	Oui	Non
SortedMap	Carte triée par clés	Oui	Par clé	Oui

Exemple d'utilisation :

// Exemple d'utilisation de ArrayList
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
System.out.println(names.get(0)); // Alice

// Exemple d'utilisation de HashSet
Set<Integer> uniqueNumbers = new HashSet<>();
uniqueNumbers.add(1);
uniqueNumbers.add(2);
uniqueNumbers.add(1); // Doublon ignoré
System.out.println(uniqueNumbers.size()); // 2

// Exemple d'utilisation de HashMap
Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 30);
ages.put("Bob", 25);
System.out.println(ages.get("Alice")); // 30