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

CKTIS / Java

Métodos do iterador em Java: hasNext(), next() e remove()

Verifica se há mais um elemento, obtém-no e remove-o se necessário. Distingue o fim da iteração, uma sequência de chamadas inválida e uma remoção não suportada.

Versão: Java SE 21

Sintaxe

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

Em java.util.Iterator<E>, hasNext() devolve true se houver mais um elemento e false caso contrário. Apenas verifica a disponibilidade: não obtém o elemento nem faz avançar o iterador. Duas verificações seguidas não saltam, portanto, nenhum elemento.

next() devolve o elemento seguinte do tipo E e faz avançar o iterador. Se já não houver elementos, lança NoSuchElementException em vez de devolver null para assinalar o fim. Um ciclo típico usa while (it.hasNext()) e chama it.next() no corpo do ciclo.

remove() é opcional e não recebe argumentos. Se o iterador suportar esta operação, o método remove da coleção subjacente o último elemento devolvido por esse mesmo iterador. Só é permitido uma vez por cada chamada bem-sucedida a next(). Uma chamada antes do primeiro next() ou uma segunda remoção sem outra chamada bem-sucedida a next() provoca IllegalStateException. Se a remoção não for suportada, remove() lança UnsupportedOperationException; a implementação predefinida lança essa exceção sem alterar nada.

Durante a iteração, não alteres a coleção subjacente senão através de remove() desse iterador, a menos que a implementação especifique uma política de modificação concorrente. Caso contrário, o comportamento do iterador não é especificado. O contrato geral também não especifica o comportamento de remove() após forEachRemaining().

Exemplos

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

Resultado

true
true
A
IllegalStateException
B
false
NoSuchElementException
[B]
UnsupportedOperationException

As duas chamadas a `hasNext()` imprimem `true`, e o primeiro `next()` continua a devolver `A`. O iterador de `ArrayList` remove `A`, rejeita a segunda remoção e chega ao fim depois de devolver `B`. Só fica `B` na lista. O iterador da lista não modificável criada com `List.of(...)` rejeita a remoção mesmo após uma chamada bem-sucedida a `next()`.

Lições relacionadas

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

Fontes