CKTIS / Java
Metodi dell’iteratore in Java: hasNext(), next() e remove()
Controlla se c’è un altro elemento, recuperalo e rimuovilo se necessario. Distingui la fine dell’iterazione, una sequenza di chiamate non valida e una rimozione non supportata.
Versione: Java SE 21
Sintassi
java.util.Iterator<E>
boolean hasNext()
E next()
default void remove()In java.util.Iterator<E>, hasNext() restituisce true se c’è un altro elemento e false altrimenti. Controlla solo la disponibilità: non recupera l’elemento e non fa avanzare l’iteratore. Due controlli di seguito non fanno quindi saltare alcun elemento.
next() restituisce l’elemento successivo di tipo E e fa avanzare l’iteratore. Quando non rimangono elementi, lancia NoSuchElementException invece di restituire null per segnalare la fine. Un ciclo tipico usa while (it.hasNext()) e chiama it.next() nel corpo.
remove() è facoltativo e non accetta argomenti. Se supportato, rimuove dalla collezione sottostante l’ultimo elemento restituito da quello stesso iteratore. È consentito una sola volta per ogni chiamata riuscita a next(). Chiamarlo prima del primo next() o tentare una seconda rimozione senza un’altra chiamata riuscita a next() provoca IllegalStateException. Se la rimozione non è supportata, remove() lancia UnsupportedOperationException; l’implementazione predefinita lancia questa eccezione senza modificare nulla.
Durante l’iterazione non modificare la collezione sottostante se non tramite remove() dello stesso iteratore, a meno che l’implementazione non specifichi una politica di modifica concorrente. Altrimenti il comportamento dell’iteratore non è specificato. Il contratto generale non specifica neppure il comportamento di remove() dopo forEachRemaining().
Esempi
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");
}
}
}Risultato
true true A IllegalStateException B false NoSuchElementException [B] UnsupportedOperationException
Entrambe le chiamate a `hasNext()` stampano `true`, e il primo `next()` restituisce comunque `A`. L’iteratore di `ArrayList` rimuove `A`, rifiuta la seconda rimozione e si esaurisce dopo aver restituito `B`. Nella lista rimane solo `B`. L’iteratore della lista non modificabile creata con `List.of(...)` rifiuta la rimozione anche dopo una chiamata riuscita a `next()`.
Lezioni correlate
- Java · Lezione 24 · Intermedio · Versione: 2