Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Iterable.iterator(): percursos sucessivos e independentes

`Iterable.iterator()` devolve um iterador. Poder fazer percursos sucessivos não garante que os percursos sobrepostos sejam independentes nem que cada chamada devolva um novo objeto iterador.

Versão: Java SE 21

Sintaxe

Iterator<T> iterator();

Iterable.iterator() é um método de instância sem argumentos de java.lang.Iterable<T>. Devolve um java.util.Iterator<T> para percorrer elementos do tipo T. O Iterable disponibiliza os elementos a percorrer; o Iterator acompanha a posição de um percurso específico.

Uma implementação pode permitir iniciar um novo percurso depois de o anterior terminar sem admitir percursos sobrepostos. Por exemplo, pode repor o mesmo iterador na posição inicial e reutilizá-lo. Se quiseres admitir percursos independentes, como em ciclos aninhados, uma solução simples é devolver em cada chamada um iterador novo com a sua própria posição, definida no início do percurso. Se os percursos partilharem a posição, avançar num deles afeta o outro. O contrato geral de Iterable não garante que o percurso possa ser repetido: uma segunda tentativa de obter um iterador de um DirectoryStream lança IllegalStateException.

Ao percorrer os elementos manualmente, verifica hasNext() antes de chamar next(). O primeiro método verifica se ainda há um elemento sem o consumir; o segundo devolve-o e avança a posição. Quando já não há elementos, next() lança NoSuchElementException. Num Iterable, o ciclo for melhorado chama iterator() uma vez no início e depois usa hasNext() e next(). Nos arrays, usa índices em vez de um iterador.

Exemplos

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

Resultado

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

`a` devolve 1 e depois 2, mas `b` começa na mesma em 1. O ciclo `for` melhorado obtém um terceiro iterador e escreve os números de 1 a 3.

Lições relacionadas

  • Java · Lição 24 · Intermédio · Versão: 2

Fontes