Um ListIterador é um iterador que nos dá acesso elemento a elemento de uma coleção de forma bidirecional e permite executar algumas operações. O ListIterator é usado apenas por coleções ArrayList, LinkedList e outras classes que herdam da interface List.

Algumas características

1. Acesso bidirecional
2. Homogêneo

Interfaces implementadas

1. ListIterator<E>

Para a utilização da interface ListIterator, precisamos importar sua classe como na sintaxe abaixo:

Sintaxe

import java.util.ListIterator;

Para os exemplos seguintes, vamos utilizar a classe ArrayList de forma superficial para exemplificar o uso da interface ListIterator. Mais sobre ArrayList pode ser visto em Estrutura de Dados/Coleção: ArrayList.

É necessário o conhecimento sobre o uso de Generics para melhor compreensão dos exemplos.

Para recupermos um ListIterador, precisamos invocar o método listIterator pertencente à uma classe de coleção, container ou estrutura de dados que implementem a ListIterator.

Sintaxe

variavel_colecao.listIterator();

Retorno

Iterator<E>

Exemplo 1

//Main.java
import java.util.ArrayList;
import java.util.ListIterator;

public class Main
{
	public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        Iterator it = al.listIterator();
    }
}

Saída

-

A interface java.util.ListIterator fornece métodos para manipular seus dados. Abaixo uma lista de todos os métodos dessa interface.

Com essa sobrecarga do método add, podemos adicionar um elemento no fim de uma coleção de dados.

Sintaxe

public void add(E e)

Onde

e: elemento para adicionar
E: Tipo de dado do ListIterator

Retorno

true

Exception

UnsupportedOperationException
ClassCastException
IllegalArgumentException

Exemplo

//Main.java
import java.util.ArrayList;
import java.util.ListIterator;

public class Main
{
	public static void main(String[] args) {
	    
        ArrayList<String> al = new ArrayList<String>();
        
        al.add("Um");
        al.add("De");
        al.add("String");
        
        System.out.println(al);
        
        ListIterator it = al.listIterator(); //posição 0
        it.next(); //posição 1
        it.add("ListIterator");
        System.out.println(al);
    }
}

Saída

[Um, De, String]
[Um, ListIterator, De, String]

Com o método hasNext, podemos verificar se existe um próximo elemento em uma coleção de dados.

Sintaxe

public boolean hasNext()

Retorno

true se existe um próximo elemento, false caso contrário.

Exemplo

//Main.java
import java.util.ArrayList;
import java.util.ListIterator;

public class Main
{
	public static void main(String[] args) {
	    
        ArrayList<String> al = new ArrayList<String>();
        
        al.add("Um");
        al.add("ArrayList");
        al.add("De");
        al.add("String");
        
        Iterator it = al.listIterator();
        
        System.out.print(it.hasNext());
    }
}

Saída

true

Com o método hasPrevious, podemos verificar se existe um elemento anterior em uma coleção de dados em relação a posição atual no iterador.

Sintaxe

public boolean hasPrevious()

Retorno

true se existe um próximo elemento, false caso contrário.

Exemplo

//Main.java
import java.util.ArrayList;
import java.util.ListIterator;

public class Main
{
	public static void main(String[] args) {
	    
        ArrayList<String> al = new ArrayList<String>();
        
        al.add("Um");
        al.add("ListIterator");
        al.add("De");
        al.add("String");
        
        Iterator it = al.listIterator();
        
        System.out.print(it.hasNext());
    }
}

Saída

true

O método next retorna o próximo elemento da coleção de acordo com o tipo de dado utilizado na declaração. Esse método não recebe argumentos.

Sintaxe

public E next()

Onde

E: tipo de dado utilizado 

Retorno

Próximo elemento do iterador

Exemplo

//Main.java
iimport java.util.ArrayList;
import java.util.Iterator;

public class Main
{
	public static void main(String[] args) {
	    
        ArrayList<String> al = new ArrayList<String>();
        
        al.add("Um");
        al.add("ListIterator");
        al.add("De");
        al.add("String");
        
        Iterator it = al.listIterator();
        
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

Saída

Um
ListIterator
De
String

O método nextIndex retorna o índice do próximo elemento. Esse método não recebe argumentos e retorna um inteiro.

Sintaxe

public E nextIndex()

Onde

E: tipo de dado utilizado 

Retorno

Inteiro contendo o índice do próximo elemento ou size() se fim da coleção.

Exemplo

//Main.java
import java.util.ArrayList;
import java.util.ListIterator;

public class Main
{ 
	public static void main(String[] args) {
	    
        ArrayList<String> al = new ArrayList<String>();
        
        al.add("Um");
        al.add("ListIterator");
        al.add("De");
        al.add("String");
        
        Iterator it = al.listIterator();
        
        System.out.println(it.nextIndex());
    }
}

Saída

0

O método previousIndex retorna o índice do elemento anterior ao atual. Esse método não recebe argumentos e retorna um inteiro.

Sintaxe

public E nextIndex()

Onde

E: tipo de dado utilizado 

Retorno

Inteiro contendo o elemento elemento do iterador ou -1 se início da coleção.

Exemplo

//Main.java
import java.util.ArrayList;
import java.util.ListIterator;

public class Main
{
	public static void main(String[] args) {
	    
        ArrayList<String> al = new ArrayList<String>();
        
        al.add("Um");
        al.add("ArrayList");        
        al.add("De");
        al.add("String");
        
        ListIterator it = al.listIterator();
        it.next();
        System.out.println(it.previousIndex());
        it.previous();
        System.out.println(it.previousIndex());
    }
}

Saída

0
-1

Com o método remove podemos excluir um elemento na posição atual do iterador da coleção. Deve ser usado apenas uma vez após a chamada do método next.

Sintaxe

public void remove()

Exception

UnsupportedOperationException
IllegalStateException

Exemplo

//Main.java
iimport java.util.ArrayList;
import java.util.Iterator;

public class Main
{
	public static void main(String[] args) {
	    
        ArrayList<String> al = new ArrayList<String>();
        
        al.add("Um");
        al.add("ArrayList");
        al.add("De");
        al.add("String");
        System.out.println(al);
        Iterator it = al.listIterator();
        it.next(); 
        it.remove();
        System.out.println(al);
    }
}

Saída

[Um, ArrayList, De, String]
[ArrayList, De, String]

Utilizando o método set podemos substituir ou atualizar o elemento atual apontado pelo iterador. Deve ser utilizado somente após a chamada dos métodos next ou previous.

Sintaxe

public void set(E e)

Onde

e: elemento ou valor para atualização

Exception

UnsupportedOperationException
ClassCastException
IllegalArgumentException
IllegalStateException

Exemplo

//Main.java
import java.util.ArrayList;
import java.util.ListIterator;

public class Main
{
	public static void main(String[] args) {
	    
        ArrayList<String> al = new ArrayList<String>();
        
        al.add("Um");
        al.add("X");        
        al.add("De");
        al.add("String");
        
        System.out.println(al);
        
        ListIterator it = al.listIterator();
        
        it.next();//Um
        it.next();//X
        
        it.set("ListIterator"); //X <- ListIterator
        System.out.println(al);
    }
}

Saída

[Um, X, De, String]
[Um, ListIterator, De, String]

1. 24/07/2025 - revisão 3 - correções pontuais; ajustes: sintaxes, Tab.1 links movidos para métodos
2. 24/09/2024 - revisão 2 - Correção em exemplo 'next'/'nextIndex'; outros ajustes
3. 08/02/2024 - revisão 1 - correção em navegação e erros gramaticais
4. 04/09/2023 - versão inicial