Les collections Java offrent des structures de données plus flexibles que les tableaux. Cette section présente le besoin des collections et les concepts de List, Set et Map.

8.1Introduction aux collections

8.1.1 – Besoin des collections

Les collections Java sont des structures de données qui permettent de stocker et manipuler des groupes d'objets de manière plus flexible que les tableaux. Elles offrent des fonctionnalités avancées comme la taille dynamique, la recherche, le tri, et bien plus encore.

❌ Limitations des tableaux

Les tableaux en Java ont plusieurs limitations :

Taille fixe : Une fois créé, la taille d'un tableau ne peut pas changer
Pas de méthodes utilitaires : Pas de méthodes intégrées pour rechercher, trier, etc.
Gestion manuelle : Vous devez gérer manuellement l'ajout, la suppression, etc.

Exemple : Limitations des tableaux

// Tableau : taille fixe
String[] noms = new String[10];
noms[0] = "Alice";
noms[1] = "Bob";
// Que faire si on veut ajouter un 11ème élément ?
// Il faut créer un nouveau tableau plus grand et copier les éléments

✅ Avantages des collections

Les collections résolvent ces limitations :

Taille dynamique : S'adaptent automatiquement au nombre d'éléments
Méthodes intégrées : Recherche, tri, filtrage, etc.
Types spécialisés : List, Set, Map pour différents besoins
Performance optimisée : Implémentations optimisées selon l'usage

Exemple : Avantages des collections

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

// Collection : taille dynamique
List<String> noms = new ArrayList<>();
noms.add("Alice");      // Ajoute automatiquement
noms.add("Bob");        // Taille s'adapte
noms.add("Charlie");    // Pas besoin de gérer la taille manuellement

// Méthodes intégrées
boolean existe = noms.contains("Alice");  // Recherche
int taille = noms.size();                // Taille actuelle
noms.remove("Bob");                      // Suppression facile

📦 Package java.util

Les collections Java se trouvent dans le package java.util. Les principales interfaces sont :

Collection : Interface racine pour la plupart des collections
List : Collection ordonnée avec doublons
Set : Collection sans doublons
Map : Paires clé-valeur (n'hérite pas de Collection)

8.1.2 – List, Set, Map : concepts

Java fournit trois types principaux de collections : List, Set, et Map. Chacun a ses propres caractéristiques et cas d'usage.

📋 List (Liste)

Une List est une collection ordonnée qui peut contenir des doublons. Les éléments sont accessibles par index.

Ordonnée : Les éléments ont un ordre défini
Doublons autorisés : Peut contenir le même élément plusieurs fois
Accès par index : Accès direct aux éléments par position
Implémentations courantes : ArrayList, LinkedList

Exemple : Utilisation d'une List

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

List<String> fruits = new ArrayList<>();
fruits.add("Pomme");
fruits.add("Banane");
fruits.add("Pomme");  // Doublon autorisé

System.out.println(fruits.get(0));  // Affiche : Pomme (accès par index)
System.out.println(fruits.size());   // Affiche : 3

🔢 Set (Ensemble)

Un Set est une collection qui ne contient pas de doublons. L'ordre peut varier selon l'implémentation.

Pas de doublons : Chaque élément est unique
Ordre : Peut être ordonné (TreeSet) ou non (HashSet)
Pas d'accès par index : Pas de méthode get(index)
Implémentations courantes : HashSet, TreeSet

Exemple : Utilisation d'un Set

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

Set<String> uniques = new HashSet<>();
uniques.add("Alice");
uniques.add("Bob");
uniques.add("Alice");  // Ignoré (déjà présent)

System.out.println(uniques.size());  // Affiche : 2 (pas de doublon)

🗺️ Map (Carte)

Une Map stocke des paires clé-valeur. Chaque clé est unique et mappe à une valeur.

Clé-valeur : Stocke des paires (clé, valeur)
Clés uniques : Chaque clé ne peut apparaître qu'une fois
Accès par clé : Accès rapide aux valeurs via leur clé
Implémentations courantes : HashMap, TreeMap

Exemple : Utilisation d'une Map

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

Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 25);   // Clé : "Alice", Valeur : 25
ages.put("Bob", 30);
ages.put("Alice", 26);   // Remplace la valeur précédente

System.out.println(ages.get("Alice"));  // Affiche : 26 (accès par clé)

📊 Tableau de comparaison détaillé

Type	Description	Doublons	Ordre	Accès	Exemple d'implémentation
List	Collection ordonnée	✅ Autorisés	✅ Préservé	Par index	ArrayList, LinkedList
Set	Collection sans doublons	❌ Interdits	Variable	Itération	HashSet, TreeSet
Map	Paires clé-valeur	Clés uniques	Variable	Par clé	HashMap, TreeMap

💡 Quand utiliser chaque type ?

List : Quand vous avez besoin d'un ordre et que les doublons sont acceptables (liste de courses, historique, etc.)
Set : Quand vous voulez garantir l'unicité des éléments (tags, identifiants uniques, etc.)
Map : Quand vous avez besoin d'associer des clés à des valeurs (dictionnaire, cache, configuration, etc.)

💡 Points clés à retenir

List : Ordre + doublons, accès par index
Set : Pas de doublons, unicité garantie
Map : Paires clé-valeur, accès rapide par clé
Collections : Taille dynamique, méthodes intégrées
Package : java.util pour toutes les collections