Module Java.7 – Collections

Objectif

Maîtriser les collections Java : Array, ArrayList, HashMap et toutes les collections du framework Java pour manipuler efficacement les données.

Théorie

Array (Tableaux)

Les tableaux sont de taille fixe.

Création

// Déclaration et initialisation
int[] nombres = {10, 20, 30};
int[] autres = new int[5];  // Taille fixe : 5 éléments

// Déclaration puis initialisation
int[] nombres2;
nombres2 = new int[]{10, 20, 30};

Accès et modification

int[] nombres = {10, 20, 30};

nombres[0];           // 10 (premier élément, index 0)
nombres[1] = 25;      // Modifie le deuxième élément
nombres.length;       // 3 (longueur, pas une méthode)

Limitations

• Taille fixe (ne peut pas grandir/rétrécir)
• Pas de méthodes utilitaires
• Performance optimale pour accès direct

ArrayList

Liste dynamique qui peut grandir.

Création et utilisation

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

List<String> noms = new ArrayList<>();
noms.add("Jean");
noms.add("Marie");
noms.add(0, "Pierre");  // Insère à l'index 0

noms.get(0);            // "Pierre"
noms.size();            // 3
noms.remove("Jean");    // Retire "Jean"
noms.remove(0);         // Retire l'élément à l'index 0
noms.contains("Marie"); // true
noms.clear();           // Vide la liste

Méthodes utiles

List<Integer> nombres = new ArrayList<>();

nombres.add(10);
nombres.add(20);
nombres.add(30);

nombres.indexOf(20);        // 1
nombres.lastIndexOf(20);     // 1
nombres.isEmpty();           // false
nombres.contains(20);        // true
nombres.toArray();           // Convertit en tableau

Parcourir

// Enhanced for
for (String nom : noms) {
    System.out.println(nom);
}

// Avec index
for (int i = 0; i < noms.size(); i++) {
    System.out.println(i + ": " + noms.get(i));
}

// Iterator
Iterator<String> it = noms.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

// forEach (Java 8+)
noms.forEach(nom -> System.out.println(nom));

HashMap

Structure clé-valeur pour stocker des paires.

Création et utilisation

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

Map<String, Integer> ages = new HashMap<>();
ages.put("Jean", 30);
ages.put("Marie", 25);
ages.put("Pierre", 35);

ages.get("Jean");           // 30
ages.get("Inexistant");     // null
ages.containsKey("Jean");   // true
ages.containsValue(30);     // true
ages.remove("Jean");        // Retire la paire
ages.size();                // 2
ages.clear();               // Vide

Parcourir

// Par clés
for (String nom : ages.keySet()) {
    System.out.println(nom + ": " + ages.get(nom));
}

// Par valeurs
for (Integer age : ages.values()) {
    System.out.println(age);
}

// Par paires (entrySet)
for (Map.Entry<String, Integer> entry : ages.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// forEach (Java 8+)
ages.forEach((nom, age) -> System.out.println(nom + ": " + age));

Autres collections

HashSet

Collection de valeurs uniques.

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

Set<String> noms = new HashSet<>();
noms.add("Jean");
noms.add("Marie");
noms.add("Jean");  // Ignoré (déjà présent)

noms.contains("Jean");  // true
noms.size();            // 2

LinkedList

Liste chaînée (meilleure pour insertion/suppression).

import java.util.LinkedList;

List<String> noms = new LinkedList<>();
noms.add("Jean");
noms.addFirst("Pierre");  // Ajoute au début
noms.addLast("Marie");   // Ajoute à la fin

TreeMap

Map triée par clés.

import java.util.TreeMap;

Map<String, Integer> ages = new TreeMap<>();
ages.put("Jean", 30);
ages.put("Marie", 25);
// Automatiquement trié par ordre alphabétique des clés

Collections Framework

Hiérarchie :

• Collection (interface)
  • List (ordonnée, doublons autorisés)
    • ArrayList, LinkedList
  • Set (pas d'ordre garanti, pas de doublons)
    • HashSet, TreeSet
• Map (clé-valeur)
  • HashMap, TreeMap, LinkedHashMap

Méthodes utilitaires Collections

import java.util.Collections;

List<Integer> nombres = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5));

Collections.sort(nombres);           // Trie
Collections.reverse(nombres);        // Inverse
Collections.shuffle(nombres);        // Mélange
Collections.max(nombres);            // Maximum
Collections.min(nombres);            // Minimum
Collections.frequency(nombres, 1);   // Fréquence de 1

Exercice

1. Tableaux

   • Créez et manipulez des tableaux
   • Testez les limites (ArrayIndexOutOfBoundsException)
   • Comprenez la taille fixe

2. ArrayList

   • Créez des listes dynamiques
   • Testez toutes les méthodes
   • Parcourez de différentes manières

3. HashMap

   • Créez des maps
   • Stockez et récupérez des valeurs
   • Parcourez avec entrySet

4. Autres collections

   • Testez HashSet, TreeMap
   • Comprenez les différences
   • Choisissez la bonne collection

5. Collections Framework

   • Utilisez les méthodes utilitaires
   • Triez, mélangez, recherchez
   • Comparez les performances

Quiz

1. Quelle est la différence entre Array et ArrayList ?

   • Aucune différence
   • Array taille fixe, ArrayList dynamique
   • ArrayList est plus rapide

2. Comment parcourir un HashMap ?

   • for (int i = 0; i < map.size(); i++)
   • for (Map.Entry entry : map.entrySet())
   • map.forEach()

3. Que fait HashSet ?

   • Trie les éléments
   • Stocke des valeurs uniques
   • Permet les doublons

4. Quelle collection pour clé-valeur ?

   • ArrayList
   • HashMap
   • HashSet

5. Que fait Collections.sort() ?

   • Crée une nouvelle liste triée
   • Trie la liste en place
   • Retourne un tableau

Mini défi

Mission : Créer un système de gestion de données complet

Créez un système qui gère une collection de produits :

Données :

class Produit {
    int id;
    String nom;
    double prix;
    int stock;
    String categorie;
}

Fonctionnalités :

1. Recherche par nom, ID, catégorie
2. Tri par prix, stock, nom
3. Calculs (prix moyen, total stock)
4. Filtres (stock > 0, prix < seuil)
5. Groupement par catégorie (utilisez Map)

Critères :

• ✅ Utilisation de ArrayList et HashMap
• ✅ Méthodes de collections appropriées
• ✅ Code organisé
• ✅ Performance optimisée

Objectif : Maîtriser toutes les collections Java et savoir choisir la bonne pour chaque situation.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez Array, ArrayList, HashMap et pouvez les utiliser efficacement.