Java ListIterator – ListIterator em Java

Como sabemos, Java tem quatro cursores: Enumeração, Iterador, ListIterator e Spliterator. Já discutimos sobre os cursores Enumeração e Iterador no meu post anterior. Antes de prosseguir com este post, por favor, leia meu post anterior em: Java Iterator. Neste post, discutiremos sobre o terceiro cursor Java: ListIterator.

Java ListIterator

Assim como o Iterador, ListIterator é um Iterador Java, que é usado para iterar elementos um por um de um objeto implementado por Lista.

• Está disponível desde Java 1.2.
• Ele estende a interface Iterador.
• É útil apenas para classes implementadas por Lista.
• Ao contrário do Iterador, ele suporta todas as quatro operações: CRUD (CREATE, READ, UPDATE e DELETE).
• Ao contrário do Iterador, ele suporta iterações em ambas as direções: para frente e para trás.
• É um Iterador Bidirecional.
• Não tem um elemento atual; sua posição do cursor sempre está entre o elemento que seria retornado por uma chamada para previous() e o elemento que seria retornado por uma chamada para next().

NOTA:- O que são operações CRUD na API de Coleções?

• CREATE: Adicionar novos elementos ao objeto de Coleção.
• READ: Recuperar elementos do objeto de Coleção.
• ATUALIZAÇÃO: Atualizando ou definindo elementos existentes no objeto de Coleção.
• EXCLUSÃO: Removendo elementos do objeto de Coleção.

Diagrama de Classe da Classe Java ListIterator

No Java, ListIterator é uma interface na API de Coleção. Ela estende a interface Iterator. Para suportar iteração nas direções para frente e para trás, assim como operações de CRUD, possui os seguintes métodos. Podemos usar esse Iterator para todas as classes implementadas de List, como ArrayList, CopyOnWriteArrayList, LinkedList, Stack, Vector, etc. Vamos explorar esses métodos em profundidade com alguns métodos úteis nas próximas seções.

Métodos do ListIterator Java

A interface ListIterator do Java possui os seguintes métodos.

• void add(E e): Insere o elemento especificado na lista.
• boolean hasNext(): Retorna verdadeiro se este iterador de lista tiver mais elementos ao percorrer a lista na direção para frente.
• boolean hasPrevious(): Retorna verdadeiro se este iterador de lista tiver mais elementos ao percorrer a lista na direção reversa.
• E next(): Returns the next element in the list and advances the cursor position.
• int nextIndex(): Retorna o índice do elemento que seria retornado por uma chamada subsequente de next().
• E previous(): Returns the previous element in the list and moves the cursor position backwards.
• int previousIndex(): Retorna o índice do elemento que seria retornado por uma chamada subsequente de previous().
• void remove(): Remove da lista o último elemento que foi retornado por next() ou previous().
• void set(E e): Substitui o último elemento retornado por next() ou previous() com o elemento especificado.

Vamos explorar esses métodos um por um com exemplos úteis nas próximas seções.

Exemplo Básico de ListIterator em Java

Nesta seção, discutiremos alguns métodos do ListIterator com exemplos. Primeiro, precisamos entender como obter esse objeto iterador. Como obter ListIterator?

ListIterator<E> listIterator()

Ele retorna um iterador de lista sobre os elementos nesta lista. Exemplo:-

import java.util.*;

public class ListIteratorDemo 
{
  public static void main(String[] args) 
  {
	List();
	names.add("Rams");
	names.add("Posa");
	names.add("Chinni");
		
	// Obtendo ListIterator
	ListIterator<String> namesIterator = names.listIterator();
	
	// Percorrendo os elementos
	while(namesIterator.hasNext()){
	   System.out.println(namesIterator.next());			
	}	

	// O loop for aprimorado cria um Iterador Interno aqui.
	for(String name: names){
	   System.out.println(name);			
	}	
  }
}

Saída:-

Rams
Posa
Chinni

Exemplo de Iteração Bidirecional com ListIterator

Na seção, exploraremos como os métodos do ListIterator funcionam para realizar iterações na Direção para Frente e na Direção para Trás.

import java.util.*;

public class BiDirectinalListIteratorDemo 
{
	public static void main(String[] args) 
	{
		List();
		names.add("Rams");
		names.add("Posa");
		names.add("Chinni");
		
		// Obtendo ListIterator
		ListIterator<String> listIterator = names.listIterator();
		
		// Percorrendo elementos
		System.out.println("Forward Direction Iteration:");
		while(listIterator.hasNext()){
			System.out.println(listIterator.next());			
		}	
		
		// Percorrendo elementos, the iterator is at the end at this point
		System.out.println("Backward Direction Iteration:");
		while(listIterator.hasPrevious()){
			System.out.println(listIterator.previous());			
		}
	}
}

Saída:-

Forward Direction Iteration:
Rams
Posa
Chinni
Backward Direction Iteration:
Chinni
Posa
Rams

Tipos de Iteradores em Java

Como sabemos, o Java possui quatro cursores: Enumeration, Iterator, ListIterator e Spliterator. Podemos categorizá-los em dois tipos principais, como mostrado abaixo:

• Iteradores Uni-direcionais
  São cursores que suportam apenas iterações na Direção para Frente. Por exemplo, Enumeration, Iterator, etc., são Iteradores Uni-direcionais.- Iteradores Bi-direcionais
  São cursores que suportam iterações tanto na Direção para Frente quanto na Direção para Trás. Por exemplo, o ListIterator é um Iterador Bi-direcional.

Como o ListIterator do Java Funciona Internamente?

Como sabemos, o ListIterator do Java funciona em ambas as direções, o que significa que funciona tanto na direção para frente quanto na direção para trás. É um Iterador Bi-direcional. Para suportar essa funcionalidade, ele possui dois conjuntos de métodos.

• Métodos de Iteração em Direção à Frente
  Precisamos usar os seguintes métodos para suportar a Iteração em Direção à Frente:

1. hasNext())
2. next()
3. nextIndex()

• Métodos de Iteração em Direção à Ré
  Precisamos usar os seguintes métodos para suportar a Iteração em Direção à Ré:

1. hasPrevious()
2. previous()
3. previousIndex()

Em minha postagem anterior, já discutimos como um Iterador funciona internamente na Direção à Frente na seção “Como o Iterator do Java Funciona Internamente?” Mesmo ListIterator funciona da mesma forma. Se você quiser revisar minha postagem anterior, clique aqui: Java Iterator. Nesta seção, discutiremos como o ListIterator funciona na Direção à Ré. Vamos usar o seguinte objeto LinkedList para entender essa funcionalidade.

List<String> names = new LinkedList<>();
names.add("E-1");
names.add("E-2");
names.add("E-3");
.
.
.
names.add("E-n");

Agora crie um objeto ListIterator na LinkedList, como mostrado abaixo:

ListIterator<String> namesIterator = names.listLterator();

Vamos supor que o ListIterator “namesIterator” parece o seguinte: Aqui, o Cursor do ListIterator está apontando antes do primeiro elemento da Lista. Agora, executamos o trecho de código a seguir em um loop while.

namesIterator.hasNext();
namesIterator.next();

Ao executar o trecho de código acima em um loop while, o Cursor do ListIterator aponta para o último elemento na LinkedList. Em seguida, podemos executar o trecho de código a seguir para começar a percorrer do final para o início.

namesIterator.hasPrevious();
namesIterator.previous();

Quando executamos o trecho de código acima, o Cursor do ListIterator aponta para o “Penúltimo” elemento na Lista, conforme mostrado no diagrama acima. Faça esse processo para levar o Cursor do ListIterator ao primeiro elemento da LinkedList. Depois de ler o primeiro elemento, se executarmos o trecho de código abaixo, ele retornará o valor “false”.

namesIterator.hasPrevious();

Como o Cursor do ListIterator aponta para antes do primeiro elemento da LinkedList, o método hasPrevious() retorna um valor falso. Após observar todos esses diagramas, podemos dizer que o ListIterator do Java suporta Iterações em Ambas as Direções, conforme mostrado nos diagramas abaixo. Por isso, também é conhecido como Cursor Bidirecional. Direção de Iteração para Frente do ListIterator Direção de Iteração para Trás do ListIterator

Vantagens do ListIterator

Ao contrário do Iterator, o ListIterator tem as seguintes vantagens:

• Assim como o Iterator, ele suporta operações de LEITURA e EXCLUSÃO.
• Também suporta operações de CRIAÇÃO e ATUALIZAÇÃO.
• Isso significa que suporta operações CRUD: operações CREATE, READ, UPDATE e DELETE.
• Suporta tanto a iteração na direção para frente quanto na direção para trás. Isso significa que é um Cursor Java Bidirecional.
• Os nomes dos métodos são simples e fáceis de usar.

Limitações do ListIterator

Comparado com o Iterator, o Java ListIterator tem muitas vantagens. No entanto, ainda possui algumas limitações a seguir.

• É uma implementação de lista apenas para Iterators.
• Ao contrário do Iterator, não é aplicável para toda a API de Coleções.
• Não é um Cursor Java Universal.
• Comparado com o Spliterator, NÃO suporta iteração paralela de elementos.
• Comparado com o Spliterator, NÃO oferece melhor desempenho para iterar grandes volumes de dados.

Similaridades entre Iterator e ListIterator

Nesta seção, discutiremos as semelhanças entre os dois Cursores Java: Iterator e ListIterator.

• Ambos foram introduzidos no Java 1.2.
• Ambos são Iterators usados para iterar elementos de Coleção ou Lista.
• Ambos suportam operações de LEITURA e EXCLUSÃO.
• Ambos suportam iteração na Direção para Frente.
• Ambos não são interfaces Legadas.

Diferenças entre Iterator e ListIterator

Nesta seção, discutiremos as diferenças entre dois Iteradores em Java: Iterator e ListIterator.

Isso resume sobre o ListIterator em Java. Espero que essas teorias e exemplos de ListIterator em Java ajudem você a começar com a programação de ListIterator. Referência: Documento da API do ListIterator