8.2.2 – Parcours d'une collection

Il existe plusieurs façons de parcourir une collection en Java : boucle for-each, Iterator, et méthodes forEach (Java 8+).

🔄 Boucle for-each (recommandée)

La boucle for-each est la méthode la plus simple et la plus lisible pour parcourir une collection.

Exemple : Parcours avec for-each

List<String> liste = new ArrayList<>();
liste.add("Alice");
liste.add("Bob");
liste.add("Charlie");

// Parcours simple
for (String element : liste) {
    System.out.println(element);
}

// Parcours d'une Map
Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 25);
ages.put("Bob", 30);

// Parcourir les clés
for (String nom : ages.keySet()) {
    System.out.println(nom);
}

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

// Parcourir les paires clé-valeur
for (Map.Entry<String, Integer> entry : ages.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}

🔍 Iterator

L'Iterator permet un contrôle plus fin sur le parcours, notamment pour supprimer des éléments pendant l'itération.

Exemple : Parcours avec Iterator

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

List<String> liste = new ArrayList<>();
liste.add("Alice");
liste.add("Bob");
liste.add("Charlie");

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

// Supprimer pendant l'itération (sécurisé)
Iterator<String> it2 = liste.iterator();
while (it2.hasNext()) {
    String element = it2.next();
    if (element.equals("Bob")) {
        it2.remove();  // Supprime l'élément courant
    }
}

↔️ ListIterator - Parcours bidirectionnel

Le ListIterator est une interface qui étend Iterator et permet de parcourir une liste dans les deux sens (avant et arrière). Il offre également des fonctionnalités supplémentaires comme l'ajout et la modification d'éléments pendant le parcours.

🔑 Caractéristiques de ListIterator

• Parcours bidirectionnel : Peut parcourir la liste vers l'avant et vers l'arrière
• Accès à l'index : Permet d'obtenir l'index de l'élément courant
• Modification : Permet d'ajouter, modifier et supprimer des éléments
• Spécifique aux List : Fonctionne uniquement avec les implémentations de List (ArrayList, LinkedList, etc.)

📋 Méthodes principales de ListIterator

➡️ Parcours vers l'avant

Exemple : Parcours classique vers l'avant

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

List<String> liste = new ArrayList<>();
liste.add("Alice");
liste.add("Bob");
liste.add("Charlie");

// Créer un ListIterator
ListIterator<String> it = liste.listIterator();

// Parcourir vers l'avant
while (it.hasNext()) {
    String element = it.next();
    int index = it.previousIndex();  // Index de l'élément courant (après next())
    System.out.println("Index " + index + " : " + element);
}
// Affiche :
// Index 0 : Alice
// Index 1 : Bob
// Index 2 : Charlie

⬅️ Parcours vers l'arrière

Exemple : Parcours vers l'arrière

List<String> liste = new ArrayList<>();
liste.add("Alice");
liste.add("Bob");
liste.add("Charlie");

// Créer un ListIterator positionné à la fin
ListIterator<String> it = liste.listIterator(liste.size());

// Parcourir vers l'arrière
while (it.hasPrevious()) {
    String element = it.previous();
    int index = it.nextIndex();  // Index de l'élément suivant (après previous())
    System.out.println("Index " + index + " : " + element);
}
// Affiche :
// Index 2 : Charlie
// Index 1 : Bob
// Index 0 : Alice

↔️ Parcours dans les deux sens

Exemple : Parcours aller-retour

List<String> liste = new ArrayList<>();
liste.add("Alice");
liste.add("Bob");
liste.add("Charlie");
liste.add("David");

ListIterator<String> it = liste.listIterator();

// Parcourir vers l'avant jusqu'au milieu
System.out.println("Parcours vers l'avant :");
while (it.nextIndex() < liste.size() / 2) {
    System.out.println(it.next());
}
// Affiche : Alice, Bob

// Maintenant parcourir vers l'arrière
System.out.println("\nParcours vers l'arrière :");
while (it.hasPrevious()) {
    System.out.println(it.previous());
}
// Affiche : Bob, Alice

➕ Ajouter des éléments avec ListIterator

Exemple : Ajout d'éléments pendant le parcours

List<String> liste = new ArrayList<>();
liste.add("Alice");
liste.add("Bob");
liste.add("Charlie");

ListIterator<String> it = liste.listIterator();

// Parcourir et ajouter des éléments
while (it.hasNext()) {
    String element = it.next();
    if (element.equals("Bob")) {
        // Ajouter un élément après "Bob"
        it.add("Bobette");  // Ajoute à la position courante
    }
}

System.out.println(liste);
// Affiche : [Alice, Bob, Bobette, Charlie]

✏️ Modifier des éléments avec ListIterator

Exemple : Modification d'éléments

List<String> liste = new ArrayList<>();
liste.add("alice");
liste.add("bob");
liste.add("charlie");

ListIterator<String> it = liste.listIterator();

// Parcourir et mettre en majuscules
while (it.hasNext()) {
    String element = it.next();
    // Modifier l'élément courant
    it.set(element.toUpperCase());  // Remplace l'élément retourné par next()
}

System.out.println(liste);
// Affiche : [ALICE, BOB, CHARLIE]

🗑️ Supprimer des éléments avec ListIterator

Exemple : Suppression pendant le parcours

List<String> liste = new ArrayList<>();
liste.add("Alice");
liste.add("Bob");
liste.add("Charlie");
liste.add("David");

ListIterator<String> it = liste.listIterator();

// Supprimer les éléments qui commencent par "C"
while (it.hasNext()) {
    String element = it.next();
    if (element.startsWith("C")) {
        it.remove();  // Supprime l'élément retourné par next()
    }
}

System.out.println(liste);
// Affiche : [Alice, Bob, David]

📍 Positionnement du ListIterator

Vous pouvez créer un ListIterator à une position spécifique :

List<String> liste = new ArrayList<>();
liste.add("Alice");
liste.add("Bob");
liste.add("Charlie");
liste.add("David");

// Créer un ListIterator à l'index 2 (après "Bob")
ListIterator<String> it = liste.listIterator(2);

// L'élément suivant sera "Charlie"
System.out.println(it.next());  // Affiche : Charlie

// L'élément précédent sera "Bob"
it.previous();
System.out.println(it.previous());  // Affiche : Bob

💻 Exemple complet : Traitement bidirectionnel

Exemple : Inverser une liste avec ListIterator

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

public class InversionListe {
    public static void main(String[] args) {
        List<String> liste = new ArrayList<>();
        liste.add("A");
        liste.add("B");
        liste.add("C");
        liste.add("D");
        
        System.out.println("Liste originale : " + liste);
        
        // Inverser avec ListIterator
        ListIterator<String> avant = liste.listIterator();
        ListIterator<String> arriere = liste.listIterator(liste.size());
        
        // Échanger les éléments de chaque côté
        while (avant.nextIndex() < arriere.previousIndex()) {
            String temp = avant.next();
            avant.set(arriere.previous());
            arriere.set(temp);
        }
        
        System.out.println("Liste inversée : " + liste);
        // Affiche : Liste inversée : [D, C, B, A]
    }
}

📊 Comparaison : Iterator vs ListIterator

⚠️ Erreurs communes à éviter

Erreur 1 : Appeler set() sans next() ou previous()

ListIterator<String> it = liste.listIterator();

// ❌ ERREUR : IllegalStateException
// it.set("Nouveau");  // Pas d'élément courant défini

// ✅ CORRECT
it.next();  // Définir l'élément courant
it.set("Nouveau");  // Maintenant OK

Erreur 2 : Mélanger add() et remove() sans next()/previous()

ListIterator<String> it = liste.listIterator();
it.next();
it.add("Nouveau");

// ❌ ERREUR : IllegalStateException
// it.remove();  // Pas d'élément courant après add()

// ✅ CORRECT
it.next();  // Avancer après add()
it.remove();  // Maintenant OK

Erreur 3 : Utiliser ListIterator sur une collection non-List

Set<String> set = new HashSet<>();

// ❌ ERREUR : Set n'a pas de méthode listIterator()
// ListIterator<String> it = set.listIterator();

// ✅ CORRECT : Utiliser Iterator pour Set
Iterator<String> it = set.iterator();

💡 Points clés à retenir

• ListIterator : Permet le parcours bidirectionnel des listes
• Parcours avant : hasNext() et next()
• Parcours arrière : hasPrevious() et previous()
• Index : nextIndex() et previousIndex() pour obtenir les positions
• Ajout : add() insère un élément à la position courante
• Modification : set() remplace l'élément courant
• Suppression : remove() supprime l'élément courant
• Positionnement : listIterator(index) crée un itérateur à une position spécifique
• Spécifique aux List : Ne fonctionne qu'avec les implémentations de List

🆕 Méthode forEach (Java 8+)

Depuis Java 8, vous pouvez utiliser la méthode forEach avec des expressions lambda.

Exemple : Parcours avec forEach

List<String> liste = new ArrayList<>();
liste.add("Alice");
liste.add("Bob");
liste.add("Charlie");

// forEach avec lambda
liste.forEach(element -> System.out.println(element));

// forEach avec référence de méthode
liste.forEach(System.out::println);

// forEach sur une Map
Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 25);
ages.put("Bob", 30);

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

📊 Comparaison des méthodes de parcours

💡 Points clés à retenir

• for-each : Méthode la plus simple pour un parcours en lecture
• Iterator : Pour un contrôle fin et la suppression sécurisée
• ListIterator : Pour un parcours bidirectionnel et des modifications avancées (List uniquement)
• forEach : Style fonctionnel avec lambda (Java 8+)
• Modification : Utilisez Iterator/ListIterator pour modifier pendant le parcours
• Map : Utilisez keySet(), values(), ou entrySet() pour parcourir