Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Métodos del iterador en Java: hasNext(), next() y remove()

Comprueba si queda otro elemento, recupéralo y elimínalo si hace falta. Distingue el fin de la iteración, una secuencia de llamadas no válida y una eliminación no admitida.

Versión: Java SE 21

Sintaxis

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

En java.util.Iterator<E>, hasNext() devuelve true si queda otro elemento y false en caso contrario. Solo comprueba si hay un elemento disponible: no lo recupera ni hace avanzar el iterador. Por tanto, dos comprobaciones seguidas no se saltan ningún elemento.

next() devuelve el siguiente elemento de tipo E y hace avanzar el iterador. Si ya no quedan elementos, lanza NoSuchElementException en lugar de devolver null para indicar el fin. Un bucle típico usa while (it.hasNext()) y llama a it.next() en el cuerpo.

remove() es opcional y no recibe argumentos. Si el iterador admite la operación, elimina de la colección subyacente el último elemento devuelto por ese mismo iterador. Solo se permite una vez por cada llamada correcta a next(). Llamar a remove() antes del primer next() o intentar eliminar de nuevo sin otra llamada correcta a next() provoca IllegalStateException. Si el iterador no admite la eliminación, remove() lanza UnsupportedOperationException; la implementación predeterminada lanza esa excepción sin modificar nada.

Durante la iteración, no modifiques la colección subyacente salvo mediante remove() de ese mismo iterador, a menos que la implementación especifique una política de modificación concurrente. De lo contrario, el comportamiento del iterador no está especificado. El contrato general tampoco especifica qué ocurre si se llama a remove() después de forEachRemaining().

Ejemplos

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

Las dos llamadas a `hasNext()` imprimen `true`, y el primer `next()` sigue devolviendo `A`. El iterador de `ArrayList` elimina `A`, rechaza la segunda eliminación y se agota tras devolver `B`. Solo queda `B` en la lista. El iterador de la lista no modificable creada con `List.of(...)` rechaza la eliminación incluso después de una llamada correcta a `next()`.

Lecciones relacionadas

  • Java · Lección 24 · Intermedio · Versión: 2

Fuentes