Um iterador(Iterator) é um tipo de dado que nos dá acesso elemento a elemento de uma coleção de forma unidirecional e nos permite executar algumas operações. O tipo Iterator é uma interface. Uma abstração de seu conteúdo é mostrado abaixo:

Algumas características

1. Acesso unidirecional
2. Homogêneo

Interfaces implementadas

1. Iterator<E>

Para a utilização da interface Iterator<E>, precisamos importá-la como na sintaxe abaixo:

Sintaxe

import java.util.Iterator;

Para os exemplos seguintes, vamos utilizar a classe ArrayList de forma superficial para exemplificar o uso da interface Iterator. 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 recuperarmos um iterador, precisamos invocar o método iterator implementado pela classe da coleção, container ou semelhante.

Sintaxe

objeto_colecao.iterator();

Como Iterator<E> se trata de uma interface, não podemos instanciar um objeto utilizando a palavra reservada new. Assim, declaramos um objeto do tipo Iterador

Sintaxe

Iterator nome_objeto = objeto_colecao.iterator();

Exemplo 1

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

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

Saída

-

Os iteradores apenas possuem recursos para iterarmos sobre elementos de coleções, não permitindo por exemplo, adicionar ou alterar elementos.

Quando utilizam o comando for, como na sintaxe abaixo, para iterar sobre uma coleção de dados, estamos invocando implicitamente o iterador do tipo de dado iterado:

Sintaxe

for (tipo_elemento elem : colecao);

Exemplo 2

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

public class Main 
{
  public static void main(String[] args) 
  {
    ArrayList<Integer> al = new ArrayList<Integer>();
    al.add(1);
    al.add(2);

    for ( Integer el : al)
        System.out.println(el);
  }
}

Saída

1
2

Utilizando o comando while podemos iterar sobre os elementos de um iterador utilizando o método hasNext para validar o próximo elemento e next como no exemplo abaixo:

Exemplo 2

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

public class Main 
{
  public static void main(String[] args) 
  {
    ArrayList<Integer> al = new ArrayList<Integer>();
    al.add(1);
    al.add(2);

    Iterator<Integer> it = al.iterator();
    
    while (it.hasNext())
        System.out.println(it.next());
  }
}

Saída

1
2

A interface java.util.Interator fornece poucos métodos para manipular seus dados. Abaixo uma lista de todos os métodos dessa interface que podem ser vistos clicando em seus nomes.

Com o método forEachRemaining podemos executar um trecho de código para todos os elementos de uma coleção. Uma expressão lambda é passada como argumento.

Sintaxe

public void forEachRemaining(Consumer<? super E> action)

Onde

action: Expressão lambda
E: Tipo de dado utilizado pelo elemento da coleção

Retorno

true

Exception

NullPointerException

Exemplo

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

public class Main
{
	public static void main(String[] args) {
	    
        ArrayList<String> al = new ArrayList<String>();
        //adição de elementos
        al.add("Um");
        al.add("ArrayList");
        al.add("De");
        al.add("String");
        
        Iterator it = al.iterator();
        
        //expressão lambda como argumento
        it.forEachRemaining((el) -> {
           System.out.println(el); 
        });
    }
}

Saída

Um
ArrayList
De
String

Com o método hasNext, podemos verificar se existe um próximo elemento em uma coleção de dados. Esse método não recebe argumentos e retorna um boolean.

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.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");
        
        Iterator it = al.iterator();
        
        System.out.print(it.hasNext());
    }
}

Saída

true

Esse método é utilizado quando precisamos iterar sobre um iterador de forma manual para executar algum trecho de código dependendo da existência ou não do elemento.

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("ArrayList");
        al.add("De");
        al.add("String");
        
        Iterator it = al.iterator();
        
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

Saída

Um
ArrayList
De
String

Com o método remove podemos excluir o elemento atual da coleção apontado pelo iterador. Esse método deve ser usado apenas uma vez após a chamada do método next.

Sintaxe

public void remove()

Exception

UnsupportedOperationException
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("ListIterator");
        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, ListIterator, De, String]
[ListIterator, De, String]

1. 12/08/2026 - revisão 5 - Adição: 'Percorrer elementos'
2. 21/07/2026 - revisão 4 - Ajustes: objetivos, títulos; pontuais
3. 24/07/2025 - revisão 3 - correções pontuais; adiçao: link 'interface; ajustes: sintaxes, Tab.1 links movidos para métodos
4. 24/09/2024 - revisão 2 - correção: sintaxe 'remove'; ajustes pontuais
5. 08/02/2024 - revisão 1 - correção em navegação e erros gramaticais
6. 04/09/2023 - versão inicial