Java Academy · Leçon

ListIterator et parcours bidirectionnel

Utilisez ListIterator pour parcourir des listes vers l’avant et vers l’arrière et modifier des éléments pendant le parcours.

ListIterator et parcours bidirectionnel est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

ListIterator

ListIterator<T> étend Iterator<T> en ajoutant le parcours en sens inverse, le positionnement par index et la possibilité d’ajouter et de remplacer des éléments pendant le parcours.

API de ListIterator

Méthodes supplémentaires par rapport à Iterator : hasPrevious(), previous(), nextIndex(), previousIndex(), set(), add().

import java.util.*;

List<String> list = new ArrayList<>(List.of("A", "B", "C", "D"));
ListIterator<String> lit = list.listIterator();

// Forward traversal
while (lit.hasNext()) {
    System.out.print(lit.nextIndex() + ":" + lit.next() + " ");
}
// 0:A 1:B 2:C 3:D

System.out.println();

// Backward traversal
while (lit.hasPrevious()) {
    System.out.print(lit.previousIndex() + ":" + lit.previous() + " ");
}
// 3:D 2:C 1:B 0:A

Commencer à une position donnée

Créez un ListIterator en commençant à un index précis avec listIterator(index).

List<Integer> nums = new ArrayList<>(List.of(10, 20, 30, 40, 50));

// Start at index 2 (30)
ListIterator<Integer> lit = nums.listIterator(2);

System.out.println(lit.next());     // 30
System.out.println(lit.next());     // 40
System.out.println(lit.previous()); // 40
System.out.println(lit.previous()); // 30
System.out.println(lit.previous()); // 20

set() pendant l'itération

set() remplace le dernier élément renvoyé par next() ou previous(). Cette opération est efficace : O(1) pour LinkedList et O(1) pour ArrayList.

List<String> words = new ArrayList<>(List.of("hello", "world", "java"));
ListIterator<String> lit = words.listIterator();

while (lit.hasNext()) {
    String word = lit.next();
    lit.set(word.toUpperCase()); // replace each with uppercase
}

System.out.println(words); // [HELLO, WORLD, JAVA]

add() pendant l'itération

add(element) insère l'élément avant la position suivante. L'élément ajouté ne sera pas renvoyé par un appel ultérieur à next() : il se trouve déjà « derrière » le curseur.

List<Integer> numbers = new ArrayList<>(List.of(1, 2, 3));
ListIterator<Integer> lit = numbers.listIterator();

while (lit.hasNext()) {
    int n = lit.next();
    lit.add(n * 10); // insert n*10 after each element
}

System.out.println(numbers); // [1, 10, 2, 20, 3, 30]

Inverser une liste sur place

Utilisez ListIterator pour inverser une liste en O(n) sans allouer de nouvelle liste.

static <T> void reverse(List<T> list) {
    ListIterator<T> front = list.listIterator(0);
    ListIterator<T> back  = list.listIterator(list.size());

    for (int i = 0, n = list.size() / 2; i < n; i++) {
        T frontVal = front.next();
        T backVal  = back.previous();
        front.set(backVal);
        back.set(frontVal);
    }
}

List<String> data = new ArrayList<>(List.of("a","b","c","d","e"));
reverse(data);
System.out.println(data); // [e, d, c, b, a]

nextIndex et previousIndex

nextIndex() renvoie l'index de l'élément qui serait renvoyé par next(). previousIndex() renvoie l'index de l'élément qui serait renvoyé par previous().

List<String> list = List.of("X", "Y", "Z");
ListIterator<String> lit = list.listIterator();

System.out.println(lit.nextIndex());     // 0
System.out.println(lit.previousIndex()); // -1 (before start)

lit.next(); // consume X
System.out.println(lit.nextIndex());     // 1
System.out.println(lit.previousIndex()); // 0

Performances de ListIterator avec LinkedList

Le ListIterator de LinkedList atteint O(1) pour next/previous, car le parcours consiste à suivre des pointeurs. get(i) sur LinkedList est en O(n) : utilisez ListIterator pour parcourir la liste efficacement.

import java.util.*;

LinkedList<Integer> list = new LinkedList<>();
for (int i = 0; i < 5; i++) list.add(i * 10);

// Efficient: O(n) total for traversal via ListIterator
ListIterator<Integer> lit = list.listIterator();
while (lit.hasNext()) {
    int val = lit.next();
    if (val == 20) lit.set(99); // O(1) update
}
System.out.println(list); // [0, 10, 99, 30, 40]

Vérifier un palindrome avec ListIterator

Un exemple élégant de parcours bidirectionnel : vérifier si une liste est un palindrome.

static <T> boolean isPalindrome(List<T> list) {
    ListIterator<T> front = list.listIterator(0);
    ListIterator<T> back  = list.listIterator(list.size());

    for (int i = 0, n = list.size() / 2; i < n; i++) {
        if (!front.next().equals(back.previous())) return false;
    }
    return true;
}

System.out.println(isPalindrome(List.of(1, 2, 3, 2, 1))); // true
System.out.println(isPalindrome(List.of(1, 2, 3, 4)));    // false

Comparaison entre Iterator et ListIterator

Différences principales :

Iterator : uniquement vers l'avant, hasNext/next/remove
ListIterator : bidirectionnel, hasPrevious/previous, nextIndex/previousIndex, set/add
ListIterator s'utilise uniquement avec les listes, pas avec les ensembles ni les files

Annuler/rétablir avec ListIterator

Un éditeur de texte utilisant un curseur et ListIterator pour parcourir efficacement les caractères lors des opérations d'annulation et de rétablissement.

import java.util.*;

class TextEditor {
    private final LinkedList<Character> chars = new LinkedList<>();
    private ListIterator<Character> cursor;

    TextEditor() { cursor = chars.listIterator(); }

    void type(char c) { cursor.add(c); } // insert before cursor

    void moveCursorLeft()  { if (cursor.hasPrevious()) cursor.previous(); }
    void moveCursorRight() { if (cursor.hasNext()) cursor.next(); }

    void backspace() {
        if (cursor.hasPrevious()) { cursor.previous(); cursor.remove(); }
    }

    String text() {
        StringBuilder sb = new StringBuilder();
        chars.forEach(sb::append);
        return sb.toString();
    }
}

TextEditor ed = new TextEditor();
ed.type('H'); ed.type('e'); ed.type('l'); ed.type('o');
ed.moveCursorLeft(); ed.moveCursorLeft();
ed.type('l');
System.out.println(ed.text()); // Hello

Quand utiliser ListIterator

Utilisez ListIterator lorsque vous avez besoin :

de parcourir une liste en sens inverse
de remplacer des éléments pendant le parcours avec set()
d'insérer des éléments pendant le parcours avec add()
de suivre la position avec nextIndex()/previousIndex()

Vérification rapide

Que fait ListIterator.set() ?

Récapitulatif : ListIterator et parcours bidirectionnel

Points essentiels :

ListIterator étend Iterator avec hasPrevious(), previous(), set() et add()
Créez un ListIterator à une position précise avec listIterator(index)
set() remplace le dernier élément renvoyé par next() ou previous()
add() insère un élément avant la position actuelle du curseur
nextIndex() et previousIndex() fournissent des informations sur la position
Utilisez ListIterator avec LinkedList pour un parcours et des modifications en O(1)

Questions Fréquemment Posées

La leçon « ListIterator et parcours bidirectionnel » est-elle gratuite ?

Oui — le texte complet de « ListIterator et parcours bidirectionnel » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « ListIterator et parcours bidirectionnel » ?

Utilisez ListIterator pour parcourir des listes vers l’avant et vers l’arrière et modifier des éléments pendant le parcours. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « ListIterator et parcours bidirectionnel » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Contrats d’Iterable et d’Iterator
Implémenter un itérateur personnalisé
ListIterator et parcours bidirectionnel
Itérateurs à échec rapide et tolérants aux modifications

← Retour à Java Academy