ListIterator Java – ListIterator in Java

Come sappiamo, Java ha quattro cursori: Enumeration, Iterator, ListIterator e Spliterator. Abbiamo già discusso dei cursori Enumeration e Iterator nel mio post precedente. Prima di leggere questo post, ti prego di leggere il mio post precedente su: Java Iterator. In questo post, discuteremo del terzo cursore Java: ListIterator.

Java ListIterator

Come l’Iterator, il ListIterator è un’implementazione di Iterator in Java, utilizzata per iterare gli elementi uno per uno da un oggetto implementato come una List.

• È disponibile dalla versione Java 1.2.
• Estende l’interfaccia Iterator.
• È utile solo per le classi implementate come List.
• A differenza dell’Iterator, supporta tutte e quattro le operazioni: CREATE, READ, UPDATE e DELETE (CRUD).
• A differenza dell’Iterator, supporta iterazioni sia in avanti che all’indietro.
• È un iteratore bidirezionale.
• Non ha un elemento corrente; la sua posizione del cursore si trova sempre tra l’elemento che sarebbe restituito da una chiamata a previous() e l’elemento che sarebbe restituito da una chiamata a next().

NOTA: Cosa sono le operazioni CRUD nell’API Collection?

• CREATE: Aggiunta di nuovi elementi all’oggetto Collection.
• READ: Recupero degli elementi dall’oggetto Collection.
• AGGIORNAMENTO: Aggiornare o impostare elementi esistenti nell’oggetto Collection.
• ELIMINA: Rimuovere elementi dall’oggetto Collection.

Diagramma di classe della classe ListIterator di Java

In Java, ListIterator è un’interfaccia nell’API Collection. Estende l’interfaccia Iterator. Per supportare l’iterazione in avanti e all’indietro e le operazioni CRUD, ha i seguenti metodi. Possiamo utilizzare questo iteratore per tutte le classi implementate come ArrayList, CopyOnWriteArrayList, LinkedList, Stack, Vector, ecc. Esploreremo questi metodi in modo approfondito con alcuni metodi utili nelle sezioni successive.

Metodi di ListIterator di Java

L’interfaccia ListIterator di Java ha i seguenti metodi.

• void add(E e): Inserisce l’elemento specificato nella lista.
• boolean hasNext(): Restituisce true se questo list iterator ha altri elementi durante la scansione della lista in avanti.
• boolean hasPrevious(): Restituisce true se questo list iterator ha altri elementi durante la scansione della lista all’indietro.
• E next(): Returns the next element in the list and advances the cursor position.
• int nextIndex(): Restituisce l’indice dell’elemento che sarebbe restituito da una successiva chiamata a next().
• E previous(): Returns the previous element in the list and moves the cursor position backwards.
• int previousIndex(): Restituisce l’indice dell’elemento che sarebbe restituito da una successiva chiamata a previous().
• void remove(): Rimuove dalla lista l’ultimo elemento restituito da next() o previous().
• void set(E e): Sostituisce l’ultimo elemento restituito da next() o previous() con l’elemento specificato.

Esploreremo questi metodi uno per uno con esempi utili nelle sezioni successive.

Esempio di base di Java ListIterator

In questa sezione discuteremo alcuni metodi di ListIterator con alcuni esempi. Prima di tutto, dobbiamo capire come ottenere questo oggetto iterator. Come ottenere ListIterator?

ListIterator<E> listIterator()

Restituisce un iteratore di lista sugli elementi di questa lista. Esempio:-

import java.util.*;

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

	// Il ciclo for migliorato crea un iteratore interno qui.
	for(String name: names){
	   System.out.println(name);			
	}	
  }
}

Output:-

Rams
Posa
Chinni

Esempio di iterazione bidirezionale con ListIterator

Nella sezione, esploreremo come funzionano i metodi di ListIterator per eseguire iterazioni in avanti e indietro.

import java.util.*;

public class BiDirectinalListIteratorDemo 
{
	public static void main(String[] args) 
	{
		List();
		names.add("Rams");
		names.add("Posa");
		names.add("Chinni");
		
		// Ottenere ListIterator
		ListIterator<String> listIterator = names.listIterator();
		
		// Attraversare gli elementi
		System.out.println("Forward Direction Iteration:");
		while(listIterator.hasNext()){
			System.out.println(listIterator.next());			
		}	
		
		// Attraversare gli elementi, 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

Tipi di iteratori in Java

Come sappiamo, Java ha quattro cursori: Enumeration, Iterator, ListIterator e Spliterator. Possiamo suddividerli in due tipi principali come mostrato di seguito:

• Iteratori unidirezionali
  Sono cursori che supportano solo iterazioni in avanti. Ad esempio, Enumeration, Iterator, ecc. sono iteratori unidirezionali.- Iteratori bidirezionali
  Sono cursori che supportano iterazioni sia in avanti che all’indietro. Ad esempio, ListIterator è un iteratore bidirezionale.

Come funziona internamente ListIterator in Java?

Come sappiamo, ListIterator in Java funziona in entrambe le direzioni, cioè in avanti e all’indietro. È un iteratore bidirezionale. Per supportare questa funzionalità, ha due insiemi di metodi.

• Metodi di iterazione in avanti
  Dobbiamo utilizzare i seguenti metodi per supportare l’iterazione in avanti:

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

• Metodi di iterazione all’indietro
  Dobbiamo utilizzare i seguenti metodi per supportare l’iterazione all’indietro:

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

Nel mio post precedente, abbiamo già discusso di come funziona internamente un Iterator in avanti nella sezione “Come funziona internamente l’iteratore Java?”. Anche ListIterator funziona allo stesso modo. Se vuoi leggere il mio post precedente, fai clic qui: Java Iterator. In questa sezione, discuteremo di come funziona ListIterator all’indietro. Prendiamo l’oggetto LinkedList seguente per capire questa funzionalità.

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

Ora crea un oggetto ListIterator su LinkedList come mostrato di seguito:

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

Supponiamo che “namesIterator” ListIterator sia così: Qui il cursore di ListIterator punta prima del primo elemento della lista. Ora eseguiamo il seguente frammento di codice nel ciclo while.

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

Quando eseguiamo il frammento di codice sopra nel ciclo while, il cursore di ListIterator punta all’ultimo elemento nella LinkedList. Quindi possiamo eseguire il seguente frammento di codice per iniziare a attraversare dalla fine all’inizio.

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

Quando eseguiamo il frammento di codice sopra, il cursore di ListIterator punta all’elemento “ultimo ma uno” nella lista come mostrato nel diagramma sopra. Effettua questo processo per portare il cursore di ListIterator al primo elemento della LinkedList. Dopo aver letto il primo elemento, se eseguiamo il frammento di codice sottostante, restituisce il valore “falso”.

namesIterator.hasPrevious();

Poiché il cursore di ListIterator punta prima del primo elemento della LinkedList, il metodo hasPrevious() restituisce un valore falso. Dopo aver osservato tutti questi diagrammi, possiamo dire che ListIterator di Java supporta sia l’iterazione in avanti che l’iterazione all’indietro come mostrato nei diagrammi sottostanti. Pertanto, è anche conosciuto come cursore bidirezionale. Iterazione in avanti di ListIterator Iterazione all’indietro di ListIterator

Vantaggi di ListIterator

A differenza di Iterator, ListIterator ha i seguenti vantaggi:

• Come Iterator, supporta operazioni di LETTURA e ELIMINAZIONE.
• Supporta anche operazioni di CREAZIONE e AGGIORNAMENTO.
• Ciò significa che supporta le operazioni CRUD: operazioni di CREAZIONE, LETTURA, AGGIORNAMENTO ed ELIMINAZIONE.
• Supporta sia l’iterazione in avanti che all’indietro. Ciò significa che è un cursore Java bidirezionale.
• I nomi dei metodi sono semplici e facili da usare.

Limitazioni di ListIterator

Se confrontato con l’iteratore, il ListIterator di Java ha molti vantaggi. Tuttavia, presenta ancora alcune limitazioni seguenti.

• È un’implementazione dell’iteratore solo per le classi di implementazione della lista.
• A differenza dell’iteratore, non è applicabile a tutta l’API della collezione.
• Non è un cursore Java universale.
• Rispetto allo Spliterator, NON supporta l’iterazione parallela degli elementi.
• Rispetto allo Spliterator, NON offre migliori prestazioni per iterare grandi volumi di dati.

Similarità tra Iterator e ListIterator

In questa sezione, discuteremo delle similarità tra i due cursori di Java: Iterator e ListIterator.

• Entrambi sono stati introdotti in Java 1.2.
• Sono entrambi iteratori utilizzati per iterare gli elementi di una collezione o di una lista.
• Entrambi supportano operazioni di LETTURA e ELIMINAZIONE.
• Entrambi supportano l’iterazione in avanti.
• Entrambi non sono interfacce Legacy.

Differenze tra Iterator e ListIterator

In questa sezione, discuteremo le differenze tra i due iteratori di Java: Iterator e ListIterator.

Questo è tutto su ListIterator in Java. Spero che queste teorie ed esempi su ListIterator ti aiutino a iniziare con la programmazione di ListIterator. Riferimento: Documentazione API di ListIterator