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