Dominando a Interface ListIterator do Java: Um Guia Prático

Interface ListIterator do Java

Este tutorial fornece uma visão abrangente da interface ListIterator do Java, completa com exemplos do mundo real e explicações claras.

A interface ListIterator estende Iterator e oferece travessia bidirecional, permitindo mover-se para frente e para trás através de um List enquanto realiza modificações dinamicamente.

Recursos principais incluem a capacidade de navegar, remover e substituir elementos, tornando-a uma ferramenta essencial para qualquer desenvolvedor Java trabalhando com listas.

Métodos Principais do ListIterator

• hasNext() – Retorna true se outro elemento existir à frente.
• next() – Move para e retorna o próximo elemento.
• nextIndex() – Fornece o índice do elemento que next() retornará.
• previous() – Move para trás e retorna o elemento anterior.
• previousIndex() – Fornece o índice do elemento que previous() retornará.
• remove() – Remove o último elemento retornado por next() ou previous().
• set(E e) – Substitui o último elemento retornado pelo valor especificado.

Exemplo 1: Navegando para Frente

Abaixo está um exemplo conciso demonstrando next(), nextIndex() e hasNext() em um ArrayList:

import java.util.ArrayList;
import java.util.ListIterator;

class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numeros = new ArrayList<>();
        numeros.add(1);
        numeros.add(3);
        numeros.add(2);
        System.out.println("ArrayList: " + numeros);
        ListIterator<Integer> iterador = numeros.listIterator();
        int primeiro = iterador.next();
        System.out.println("Próximo Elemento: " + primeiro);
        int proximoIndice = iterador.nextIndex();
        System.out.println("Posição do Próximo Elemento: " + proximoIndice);
        System.out.println("Existe algum próximo elemento? " + iterador.hasNext());
    }
}

Saída

ArrayList: [1, 3, 2]
Próximo Elemento: 1
Posição do Próximo Elemento: 1
Existe algum próximo elemento? true

Exemplo 2: Navegando para Trás

Este exemplo mostra previous() e previousIndex() após avançar o iterador duas vezes:

import java.util.ArrayList;
import java.util.ListIterator;

class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numeros = new ArrayList<>();
        numeros.add(1);
        numeros.add(3);
        numeros.add(2);
        System.out.println("ArrayList: " + numeros);
        ListIterator<Integer> iterador = numeros.listIterator();
        iterador.next();
        iterador.next();
        int anterior = iterador.previous();
        System.out.println("Elemento Anterior: " + anterior);
        int indiceAnterior = iterador.previousIndex();
        System.out.println("Posição do Elemento Anterior: " + indiceAnterior);
    }
}

Saída

ArrayList: [1, 3, 2]
Elemento Anterior: 3
Posição do Elemento Anterior: 0

Inicialmente, o iterador está posicionado antes do primeiro elemento, então chamar previous() lançaria uma exceção. Após duas chamadas a next(), o iterador fica entre 3 e 2, fazendo previous() retornar 3.