Java ListIterator – ListIterator in Java

Zoals we weten heeft Java vier cursors: Enumeratie, Iterator, ListIterator en Spliterator. We hebben al eerder Enumeration en Iterator cursors besproken in mijn vorige post. Voordat je deze post doorloopt, bekijk alsjeblieft mijn vorige post op: Java Iterator. In deze post zullen we het hebben over de derde Java cursor: ListIterator.

Java ListIterator

Net als Iterator is ListIterator een Java Iterator, die wordt gebruikt om elementen één voor één te doorlopen vanuit een object geïmplementeerd als List.

• Het is beschikbaar sinds Java 1.2.
• Het breidt de Iterator-interface uit.
• Het is alleen nuttig voor klassen die zijn geïmplementeerd als List.
• In tegenstelling tot Iterator, ondersteunt het alle vier bewerkingen: CRUD (CREATE, READ, UPDATE en DELETE).
• In tegenstelling tot Iterator ondersteunt het zowel voorwaartse als achterwaartse iteraties.
• Het is een bi-directionele Iterator.
• Het heeft geen huidig element; de cursorpositie ligt altijd tussen het element dat zou worden geretourneerd door een oproep naar previous() en het element dat zou worden geretourneerd door een oproep naar next().

OPMERKING:- Wat zijn CRUD-bewerkingen in de Collection API?

• CREATE: Nieuwe elementen toevoegen aan een Collection-object.
• READ: Elementen ophalen uit een Collection-object.
• UPDATE: Bijwerken of instellen van bestaande elementen in het Collection-object.
• DELETE: Verwijderen van elementen uit het Collection-object.

Java ListIterator Klassen Diagram

In Java is ListIterator een interface in de Collection API. Het breidt de Iterator-interface uit. Om voorwaartse en achterwaartse iteratie en CRUD-operaties te ondersteunen, heeft het de volgende methoden. We kunnen deze Iterator gebruiken voor alle geïmplementeerde List-klassen zoals ArrayList, CopyOnWriteArrayList, LinkedList, Stack, Vector, enz. We zullen deze methoden grondig verkennen, samen met enkele nuttige methoden in de komende secties.

Java ListIterator Methoden

Java ListIterator-interface heeft de volgende methoden.

• void add(E e): Voegt het gespecificeerde element in de lijst in.
• boolean hasNext(): Geeft true terug als deze lijstiterator meer elementen heeft bij het doorlopen van de lijst in de voorwaartse richting.
• boolean hasPrevious(): Geeft true terug als deze lijstiterator meer elementen heeft bij het doorlopen van de lijst in de omgekeerde richting.
• E next(): Returns the next element in the list and advances the cursor position.
• int nextIndex(): Geeft de index terug van het element dat zou worden geretourneerd door een volgende oproep naar next().
• E previous(): Returns the previous element in the list and moves the cursor position backwards.
• int previousIndex(): Geeft de index terug van het element dat zou worden geretourneerd door een volgende oproep naar previous().
• void remove(): Verwijdert uit de lijst het laatste element dat werd geretourneerd door next() of previous().
• void set(E e): Vervangt het laatste element dat is geretourneerd door next() of previous() door het opgegeven element.

We zullen deze methoden één voor één verkennen met nuttige voorbeelden in de komende secties.

Java ListIterator Basisvoorbeeld

In deze sectie zullen we enkele ListIterator-methoden bespreken met voorbeelden. Allereerst moeten we begrijpen hoe we dit iteratorobject kunnen krijgen. Hoe krijg je een ListIterator?

ListIterator<E> listIterator()

Het retourneert een lijstiterator over de elementen in deze lijst. Voorbeeld:-

import java.util.*;

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

	// De verbeterde for-lus creëert hier een interne iterator.
	for(String name: names){
	   System.out.println(name);			
	}	
  }
}

Output:-

Rams
Posa
Chinni

ListIterator Bi-Directional Iteratievoorbeeld

In dit gedeelte zullen we verkennen hoe de methoden van ListIterator werken om iteraties in voorwaartse en achterwaartse richting uit te voeren.

import java.util.*;

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

Soorten Java-iteratoren

Zoals we weten heeft Java vier cursors: Enumeratie, Iterator, ListIterator en Spliterator. We kunnen ze in twee hoofdtypen categoriseren zoals hieronder getoond:

• Uni-Directional Iterators
  Dit zijn cursors die alleen voorwaartse iteraties ondersteunen. Bijvoorbeeld, Enumeratie, Iterator, enz. zijn Uni-Directional Iterators.- Bi-Directional Iterators
  Dit zijn cursors die zowel voorwaartse als achterwaartse iteraties ondersteunen. Bijvoorbeeld, ListIterator is een Bi-Directional Iterator.

Hoe werkt Java ListIterator intern?

Zoals we weten, werkt Java ListIterator in beide richtingen, dat wil zeggen, het werkt in de voorwaartse richting en ook in de achterwaartse richting. Het is een Bi-directionele Iterator. Om deze functionaliteit te ondersteunen, heeft het twee sets methoden.

• Voorwaartse iteratiemethoden
  We moeten de volgende methoden gebruiken om voorwaartse iteratie te ondersteunen:

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

• Achterwaartse iteratiemethoden
  We moeten de volgende methoden gebruiken om achterwaartse iteratie te ondersteunen:

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

In mijn vorige bericht hebben we al besproken hoe een Iterator intern werkt in voorwaartse richting in de sectie “Hoe werkt Java Iterator intern?” Zelfs ListIterator werkt op dezelfde manier. Als je mijn vorige bericht wilt bekijken, klik dan hier: Java Iterator. In deze sectie zullen we bespreken hoe ListIterator werkt in achterwaartse richting. Laten we het volgende LinkedList-object nemen om deze functionaliteit te begrijpen.

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

Maak nu een ListIterator-object op LinkedList zoals hieronder getoond:

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

Laten we aannemen dat “namesIterator” ListIterator er als volgt uitziet: Hier wijst de cursor van de ListIterator naar het element vóór het eerste element van de lijst. Nu voeren we de volgende codefragment uit in de while-lus.

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

Wanneer we het bovenstaande codefragment uitvoeren in de while-lus, wijst de cursor van de ListIterator naar het laatste element in de LinkedList. Dan kunnen we het volgende codefragment uitvoeren om vanaf het einde naar het begin te traverseren.

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

Wanneer we de bovenstaande code snippet uitvoeren, wijst de Cursor van ListIterator naar het “Een na laatste” element in de lijst, zoals getoond in het bovenstaande diagram. Voer dit proces uit om de Cursor van ListIterator naar het eerste element van de LinkedList te verplaatsen. Na het lezen van het eerste element, als we de onderstaande code snippet uitvoeren, retourneert het de waarde “false”.

namesIterator.hasPrevious();

Omdat de Cursor van ListIterator wijst naar vóór het eerste element van de LinkedList, geeft de methode hasPrevious() een waarde “false” terug. Na het observeren van al deze diagrammen kunnen we zeggen dat Java ListIterator zowel voorwaartse als achterwaartse iteraties ondersteunt, zoals getoond in de onderstaande diagrammen. Het staat daarom ook bekend als een Bi-Directional Cursor. Voorwaartse ListIterator Achterwaartse ListIterator

Voordelen van ListIterator

In tegenstelling tot Iterator heeft ListIterator de volgende voordelen:

• Net als Iterator ondersteunt het LEES- en VERWIJDER-operaties.
• Het ondersteunt ook CREATE- en UPDATE-operaties.
• Dat betekent dat het CRUD-operaties ondersteunt: CREATE, READ, UPDATE en DELETE-operaties.
• Het ondersteunt zowel voorwaartse als achterwaartse iteratie. Dat betekent dat het een Bi-Directionele Java Cursor is.
• Methode namen zijn eenvoudig en gemakkelijk te gebruiken.

Beperkingen van ListIterator

In vergelijking met Iterator heeft Java ListIterator vele voordelen. Het heeft echter nog steeds de volgende beperkingen.

• Het is alleen een Iterator-implementatie voor List-klassen.
• In tegenstelling tot Iterator is het niet van toepassing op de gehele Collection API.
• Het is geen Universele Java Cursor.
• In vergelijking met Spliterator ondersteunt het GEEN Parallelle iteratie van elementen.
• In vergelijking met Spliterator ondersteunt het GEEN betere prestaties om grote hoeveelheden gegevens te doorlopen.

Overeenkomsten tussen Iterator en ListIterator

In dit gedeelte zullen we de overeenkomsten bespreken tussen de twee Java-cursors: Iterator en ListIterator.

• Beide zijn geïntroduceerd in Java 1.2.
• Beide zijn Iterators die worden gebruikt om elementen van een Collection of List te doorlopen.
• Beide ondersteunen LEES- en VERWIJDER-operaties.
• Beide ondersteunen iteratie in de voorwaartse richting.
• Beide zijn geen Legacy-interfaces.

Verschillen tussen Iterator en ListIterator

In dit gedeelte zullen we de verschillen bespreken tussen twee Java-iterators: Iterator en ListIterator.

Dat is alles over ListIterator in Java. Ik hoop dat deze Java ListIterator-theorieën en voorbeelden je zullen helpen bij het beginnen met ListIterator-programmering. Referentie: ListIterator API-documentatie