Java ListIterator – ListIterator em Java

Como sabemos, Java possui quatro cursores: Enumeração, Iterador, ListIterator e Spliterator. Já discutimos os cursores de Enumeração e Iterador em minha postagem anterior. Antes de prosseguir com esta postagem, por favor, dê uma olhada na minha postagem anterior em: Java Iterator. Nesta postagem, discutiremos sobre o terceiro cursor do Java: ListIterator.

Java ListIterator

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

• Ele está disponível desde o Java 1.2.
• Ele estende a interface Iterator.
• É útil apenas para classes implementadas de List.
• 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 tanto na Direção Avançada quanto na Direção Reversa.
• É um Iterator Bidirecional.
• Não possui 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?

• CRIAR: Adicionar novos elementos ao objeto de Coleção.
• Ler: Recuperar elementos do objeto de Coleção.
• ATUALIZAÇÃO: Atualizando ou configurando 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 oferecer suporte à iteração nas direções Forward (para frente) e Backward (para trás) e operações CRUD, ela possui os seguintes métodos. Podemos usar esse Iterador para todas as classes List implementadas, 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 Java ListIterator

A interface Java ListIterator possui os seguintes Métodos.

• void add(E e): Insere o elemento especificado na lista.
• boolean hasNext(): Retorna true se este iterador de lista tiver mais elementos ao percorrer a lista na direção para frente.
• boolean hasPrevious(): Retorna true 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 a 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 a 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() pelo elemento especificado.

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

Exemplo Básico de Java ListIterator

Nesta seção, discutiremos alguns métodos do ListIterator com exemplos. Primeiro, precisamos entender como obter esse objeto iterador. Como obter o 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 o ListIterator
	ListIterator<String> namesIterator = names.listIterator();
	
	// Percorrendo elementos
	while(namesIterator.hasNext()){
	   System.out.println(namesIterator.next());			
	}	

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

Saída:-

Rams
Posa
Chinni

Exemplo de Iteração Bidirecional do ListIterator

Na seção, vamos explorar como os métodos do ListIterator funcionam para realizar iterações em Direção para Frente e 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());			
		}
	}
}

Output:-

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

Tipos de Iteradores Java

Como sabemos, Java tem quatro cursores: Enumeração, Iterator, ListIterator e Spliterator. Podemos categorizá-los em dois tipos principais, conforme mostrado abaixo:

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

Como o ListIterator Java Funciona Internamente?

Como sabemos, o ListIterator Java trabalha em ambas as direções, ou seja, funciona na direção para frente e na direção para trás. É um Iterador Bidirecional. Para suportar essa funcionalidade, ele possui dois conjuntos de métodos.

• Métodos de Iteração em Direção para Frente

  Precisamos usar os seguintes métodos para suportar a Iteração em Direção para Frente: `

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

• Métodos de Iteração em Direção para Trás

  Precisamos usar os seguintes métodos para suportar a Iteração em Direção para Trás: `

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

Em meu post anterior, já discutimos como um Iterator funciona internamente em Direção para Frente na seção “Como o Iterator do Java Funciona Internamente?”. Até mesmo o ListIterator também funciona da mesma maneira. Se você quiser ler meu post anterior, por favor clique aqui: Iterator Java. Nesta seção, discutiremos como o ListIterator funciona em Direção para Trás. 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” se pareça com o seguinte: ` Aqui, o Cursor do ListIterator está apontando antes do primeiro elemento da Lista. Agora, executamos o seguinte trecho de código no loop while. `

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

Ao executarmos o trecho de código acima no loop while, o Cursor do ListIterator aponta para o último elemento na LinkedList. ` Então, podemos executar o seguinte trecho de código para começar a percorrer do final para o início.

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

Ao executarmos o trecho de código acima, o Cursor do ListIterator aponta para o “Penúltimo” elemento na Lista, conforme mostrado no diagrama acima. Execute este processo para posicionar o Cursor do ListIterator no primeiro elemento da LinkedList. Após 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 antes do primeiro elemento da LinkedList, o método hasPrevious() retorna um valor falso. Após observar todos esses diagramas, podemos afirmar que o Java ListIterator suporta iterações tanto na Direção Avançada quanto na Direção Reversa, como mostrado nos diagramas abaixo. Portanto, também é conhecido como Cursor Bidirecional. Direção Avançada do ListIterator Direção Reversa do ListIterator

Vantagens do ListIterator

Ao contrário do Iterator, o ListIterator possui 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 ele suporta operações CRUD: operações de CRIAÇÃO, LEITURA, ATUALIZAÇÃO e EXCLUSÃO.
• Ele suporta tanto a iteração no sentido direto quanto no sentido inverso. 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 ao Iterator, o Java ListIterator tem muitas vantagens. No entanto, ainda possui algumas limitações a seguir.

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

Similaridades entre Iterator e ListIterator

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

• Ambos foram introduzidos no Java 1.2.
• Ambos são Iteradores 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 a frente.
• Ambos não são interfaces Legadas.

Diferenças entre Iterator e ListIterator

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

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