Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Iterable.iterator(): scansioni successive e indipendenti

`Iterable.iterator()` restituisce un iteratore. Poter eseguire scansioni successive non garantisce né che le scansioni sovrapposte siano indipendenti né che ogni chiamata restituisca un nuovo oggetto iteratore.

Versione: Java SE 21

Sintassi

Iterator<T> iterator();

Iterable.iterator() è un metodo di istanza senza argomenti di java.lang.Iterable<T>. Restituisce un java.util.Iterator<T> per scorrere gli elementi di tipo T. L’Iterable mette a disposizione gli elementi da scorrere; l’Iterator tiene traccia della posizione di una singola scansione.

Un’implementazione può consentire di avviare una nuova scansione dopo che la precedente è terminata, senza supportare scansioni sovrapposte. Ad esempio, può riportare lo stesso iteratore alla posizione iniziale e riutilizzarlo. Per supportare scansioni indipendenti, come nei cicli annidati, una soluzione semplice è restituire a ogni chiamata un iteratore nuovo, con una posizione propria impostata all’inizio. Se le scansioni condividono la posizione, avanzare in una influenza l’altra. Il contratto generale di Iterable non garantisce che la scansione sia ripetibile: un secondo tentativo di ottenere un iteratore da un DirectoryStream lancia IllegalStateException.

Quando scorri gli elementi manualmente, controlla hasNext() prima di chiamare next(). Il primo metodo verifica se rimane un elemento senza consumarlo; il secondo lo restituisce e fa avanzare la posizione. Quando gli elementi sono esauriti, next() lancia NoSuchElementException. Su un Iterable, il ciclo for avanzato chiama iterator() una volta all’inizio, poi usa hasNext() e next(). Sugli array usa invece gli indici.

Esempi

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);
        }
    }
}

Risultato

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

`a` restituisce 1 e poi 2, ma `b` parte comunque da 1. Il ciclo `for` avanzato ottiene un terzo iteratore e stampa i numeri da 1 a 3.

Lezioni correlate

  • Java · Lezione 24 · Intermedio · Versione: 2

Fonti