Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Méthodes de l’itérateur Java : hasNext(), next() et remove()

Vérifiez si un élément reste à parcourir, récupérez-le et supprimez-le si nécessaire. Distinguez la fin du parcours, un ordre d’appel incorrect et une suppression non prise en charge.

Version : Java SE 21

Syntaxe

java.util.Iterator<E>
boolean hasNext()
E next()
default void remove()

Dans java.util.Iterator<E>, hasNext() renvoie true s’il reste un élément, sinon false. La méthode vérifie seulement sa disponibilité : elle ne récupère aucun élément et ne fait pas avancer l’itérateur. Deux vérifications consécutives ne sautent donc aucun élément.

next() renvoie l’élément suivant de type E et fait avancer l’itérateur. S’il ne reste aucun élément, la méthode lève NoSuchElementException au lieu de renvoyer null pour signaler la fin. Une boucle typique utilise while (it.hasNext()) et appelle it.next() dans son corps.

remove() est facultative et ne prend aucun argument. Si l’itérateur la prend en charge, elle supprime de la collection sous-jacente le dernier élément renvoyé par ce même itérateur. Elle n’est permise qu’une fois par appel réussi à next(). Un appel avant le premier next(), ou une seconde suppression sans nouvel appel réussi à next(), provoque IllegalStateException. Si la suppression n’est pas prise en charge, remove() lève UnsupportedOperationException ; l’implémentation par défaut lève cette exception sans rien modifier.

Pendant le parcours, ne modifiez pas la collection sous-jacente autrement qu’avec remove() sur cet itérateur, sauf si l’implémentation spécifie une politique de modification concurrente. Sinon, le comportement de l’itérateur n’est pas spécifié. Le contrat général ne spécifie pas non plus le comportement de remove() après forEachRemaining().

Exemples

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

public class Main {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(List.of("A", "B"));
        Iterator<String> it = items.iterator();

        System.out.println(it.hasNext());
        System.out.println(it.hasNext());
        System.out.println(it.next());
        it.remove();
        try {
            it.remove();
        } catch (IllegalStateException e) {
            System.out.println("IllegalStateException");
        }
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println(it.hasNext());
        try {
            it.next();
        } catch (NoSuchElementException e) {
            System.out.println("NoSuchElementException");
        }
        System.out.println(items);

        Iterator<String> readOnly = List.of("A").iterator();
        readOnly.next();
        try {
            readOnly.remove();
        } catch (UnsupportedOperationException e) {
            System.out.println("UnsupportedOperationException");
        }
    }
}

Résultat

true
true
A
IllegalStateException
B
false
NoSuchElementException
[B]
UnsupportedOperationException

Les deux appels à `hasNext()` affichent `true`, et le premier `next()` renvoie toujours `A`. L’itérateur de l’`ArrayList` supprime `A`, refuse la seconde suppression, puis atteint la fin après avoir renvoyé `B`. Seul `B` reste dans la liste. L’itérateur de la liste non modifiable créée par `List.of(...)` refuse la suppression même après un appel réussi à `next()`.

Leçons associées

  • Java · Leçon 24 · Intermédiaire · Version : 2

Sources