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

CKTIS / Java

Iterable.iterator() : parcours successifs et parcours indépendants

`Iterable.iterator()` renvoie un itérateur. La possibilité d’effectuer des parcours successifs ne garantit ni l’indépendance de parcours qui se chevauchent ni la création d’un nouvel objet itérateur à chaque appel.

Version : Java SE 21

Syntaxe

Iterator<T> iterator();

Iterable.iterator() est une méthode d’instance sans argument de java.lang.Iterable<T>. Elle renvoie un java.util.Iterator<T> pour parcourir les éléments de type T. L’Iterable fournit les éléments à parcourir ; l’Iterator suit la position d’un parcours donné.

Une implémentation peut autoriser un nouveau parcours une fois le précédent terminé, sans permettre à deux parcours de se chevaucher. Elle peut par exemple réinitialiser et réutiliser le même itérateur. Pour permettre des parcours indépendants, notamment dans des boucles imbriquées, une solution simple consiste à renvoyer à chaque appel un nouvel itérateur dont la position est propre à ce parcours et initialisée au début. Si les parcours partagent la même position, avancer dans l’un affecte l’autre. Le contrat général d’Iterable ne garantit pas qu’un parcours puisse être répété : une deuxième demande d’itérateur à un DirectoryStream déclenche une IllegalStateException.

Pour parcourir les éléments manuellement, vérifiez hasNext() avant d’appeler next(). La première méthode indique s’il reste un élément, sans le consommer ; la seconde le renvoie et avance la position. Quand il ne reste plus d’élément, next() déclenche une NoSuchElementException. Sur un Iterable, la boucle for améliorée appelle iterator() une fois au début, puis utilise hasNext() et next(). Sur un tableau, elle utilise des indices à la place.

Exemples

import java.util.Iterator;
import java.util.NoSuchElementException;

public class Main {
    static final class OneToThree implements Iterable<Integer> {
        @Override
        public Iterator<Integer> iterator() {
            return new Iterator<Integer>() {
                private int nextValue = 1;

                @Override
                public boolean hasNext() {
                    return nextValue <= 3;
                }

                @Override
                public Integer next() {
                    if (!hasNext()) {
                        throw new NoSuchElementException();
                    }
                    return nextValue++;
                }
            };
        }
    }

    public static void main(String[] args) {
        Iterable<Integer> numbers = new OneToThree();
        Iterator<Integer> a = numbers.iterator();
        Iterator<Integer> b = numbers.iterator();

        System.out.println("a: " + a.next());
        System.out.println("a: " + a.next());
        System.out.println("b: " + b.next());

        for (int number : numbers) {
            System.out.println("for: " + number);
        }
    }
}

Résultat

a: 1
a: 2
b: 1
for: 1
for: 2
for: 3

`a` renvoie 1 puis 2, mais `b` commence quand même à 1. La boucle `for` améliorée obtient un troisième itérateur et affiche les nombres de 1 à 3.

Leçons associées

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

Sources