Een Java Cursor is een Iterator die wordt gebruikt om de elementen van een Collection- of Stream-object één voor één te herhalen, te doorlopen of op te halen. In dit artikel zullen we leren over Java Iterators en hoe het werkt.

Soorten cursors in Java

Er zijn drie cursors in Java zoals hieronder vermeld:

1. Iterator
2. Opsomming
3. LijstIterator

Opmerking: SplitIterator kan ook als een cursor worden beschouwd, omdat het alleen een type Iterator is.

1. Iterator

Iterators in Java worden gebruikt in de Collectiekader om elementen één voor één op te halen. Het is een universeel iterator omdat we deze op elk Collection-object kunnen toepassen. Door Iterator te gebruiken, kunnen we zowel lees- als verwijderbewerkingen uitvoeren. Het is een verbeterde versie van Enumeration met de extra functionaliteit voor het verwijderen van een element.

Iterator moet worden gebruikt wanneer we elementen willen opsommen in alle door het Collection-framework geïmplementeerde interfaces zoals Set, List, Queue, Deque en alle geïmplementeerde klassen van de Map-interface. De iterator is de alleen cursor beschikbaar voor het gehele collectieframework. Een iteratorobject kan worden gemaakt door de iterator() methode aanwezig in de collectie-interface.

Syntaxis

Iterator itr = c.  iterator  ();>

Opmerking: Hier is c een verzamelobject. itr is van het type Iterator-interface en verwijst naar c.

scanner-java importeren

Methoden van Iterator-interface in Java

De iteratorinterface definieert drie methoden zoals hieronder vermeld:

1. heeftVolgende(): Retourneert waar als de iteratie meer elementen bevat.

public boolean hasNext();>

2. volgende(): Retourneert het volgende element in de iteratie. Het gooit NoSuchElementException als er geen element meer aanwezig is.

public Object next();>

3. verwijder(): Verwijdert het volgende element in de iteratie. Deze methode kan slechts één keer per aanroep van next() worden aangeroepen.

public void remove();>

Opmerking: verwijderen() methode kan twee uitzonderingen genereren, namelijk als volgt:

• Niet-ondersteundeOperationException : Als de verwijderbewerking niet wordt ondersteund door deze iterator
• IllegaleStateException : Als de volgende methode nog niet is aangeroepen, of de verwijdermethode al is aangeroepen na de laatste aanroep van de volgende methode.

Hoe werkt Java Iterator intern?

In deze sectie zullen we proberen te begrijpen hoe Java Iterator en zijn methoden intern werken. Laten we het volgende LinkedList-object nemen om deze functionaliteit te begrijpen.

List cities = new LinkedList();  cities.add('G-1');  cities.add('G-2');  cities.add('G-3');  .  .  .  cities.add('G-n');>

Laten we nu een Iterator-object maken op het List-object, zoals hieronder weergegeven:

Iterator citiesIterator = cities.iterator();>

De citiesIteartor-iterator ziet er als volgt uit:

Hier wijst de cursor van Iterator naar het eerste element van de lijst.

Nu zullen we het volgende codefragment uitvoeren.

citiesIterator.hasNext(); citiesIterator.next();>

Wanneer we het bovenstaande codefragment uitvoeren, wijst de cursor van Iterator naar het eerste element in de lijst, zoals weergegeven in het bovenstaande diagram.

Nu zullen we het volgende codefragment uitvoeren.

citiesIterator.hasNext(); citiesIterator.next();>

Wanneer we het bovenstaande codefragment uitvoeren, wijst de cursor van Iterator naar het tweede element in de lijst, zoals weergegeven in het bovenstaande diagram. Voer dit proces uit om de cursor van de Iterator naar het eindelement van de lijst te brengen.

Als we na het lezen van het laatste element het onderstaande codefragment uitvoeren, retourneert het een valse waarde.

citiesIterator.hasNext();>

Terwijl de cursor van Iterator naar het laatste element van de lijst wijst, retourneert de methode hasNext() een valse waarde.

Opmerking: Nadat we al deze diagrammen hebben bekeken, kunnen we zeggen dat Java Iterator alleen Forward Direction Iteration ondersteunt, zoals weergegeven in het onderstaande diagram. Het wordt dus ook wel Uni-Directional Cursor genoemd.

een volledig formulier

Voorbeeld

// Java program to Demonstrate Iterator // Importing ArrayList and Iterator classes // from java.util package import java.util.ArrayList; import java.util.Iterator; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating an ArrayList class object // Declaring object of integer type ArrayList al = nieuwe ArrayList (); // Herhaal de lijst voor (int i = 0; i< 10; i++) al.add(i); // Printing the elements in the List System.out.println(al); // At the beginning itr(cursor) will point to // index just before the first element in al Iterator itr = al.iterator(); // Het volgende element controleren waarbij // de voorwaarde waar is totdat er een enkel element is // in de lijst met behulp van de hasext()-methode while (itr.hasNext()) {// Cursor naar volgend element verplaatsen int i = itr.next( ); // Elementen één voor één ophalen System.out.print(i + ' '); // Verwijderen van oneven elementen if (i % 2 != 0) itr.remove(); } // Commando voor de volgende regel System.out.println(); // Afdrukken van de elementen in het object System.out.println(al); } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9 [0, 2, 4, 6, 8]>

SplitIterator

Spliterators zijn, net als andere Iterators, bedoeld voor het doorkruisen van de elementen van een bron. Een bron kan een Verzameling , een IO-kanaal of een generatorfunctie. Het is opgenomen in JDK 8 ter ondersteuning van efficiënte parallelle verplaatsing (parallelle programmering) naast sequentiële verplaatsing. De Java Spliterator-interface is een interne iterator die de stream in kleinere delen opsplitst. Deze kleinere onderdelen kunnen parallel worden verwerkt.

Opmerking: Bij het programmeren in het echte leven hoeven we Spliterator misschien nooit rechtstreeks te gebruiken. Onder normale omstandigheden zal het zich precies hetzelfde gedragen als Java Iterator.

Voordelen van Java Iterator

• We kunnen het voor elke Collection-klasse gebruiken.
• Het ondersteunt zowel READ- als REMOVE-bewerkingen.
• Het is een universele cursor voor verzameling-API.
• Methodenamen zijn eenvoudig en gemakkelijk te gebruiken.

Beperkingen van Java Iterator

Er zijn ook bepaalde beperkingen van Iterator, die als volgt worden vermeld:

• In CRUD Operations ondersteunt het GEEN CREATE- en UPDATE-bewerkingen.
• Het ondersteunt alleen iteratie in de voorwaartse richting die een unidirectionele iterator is.
• In vergelijking met Spliterator ondersteunt het GEEN parallelle iteratie-elementen, wat betekent dat het alleen sequentiële iteratie ondersteunt.
• In vergelijking met Spliterator ondersteunt het GEEN betere prestaties bij het herhalen van grote hoeveelheden gegevens.

2. Telling

Het is een interface die wordt gebruikt om elementen van oudere collecties op te halen (Vector, Hashtable). Opsomming is de eerste iterator die aanwezig is vanaf JDK 1.0, rusten zijn opgenomen in JDK 1.2 met meer functionaliteit. Opsommingen worden ook gebruikt om de invoerstromen naar a te specificeren SequentieInputStream . We kunnen een Enumeration-object maken door te bellen elementen() methode van de vectorklasse op elk vectorobject

Syntaxis

// Here 'v' is an Vector class object. e is of // type Enumeration interface and refers to 'v' Enumeration e =   v  .  elements  ();>

Er zijn twee methoden in de Opsommingsinterface, namelijk:

1. publieke booleaanse hasMoreElements(): Deze methode test of deze opsomming meer elementen bevat of niet.

2. openbaar object nextElement(): Deze methode retourneert het volgende element van deze opsomming. Er wordt NoSuchElementException gegenereerd als er geen element meer aanwezig is

Voorbeeld

// Java program to demonstrate Enumeration // Importing Enumeration and Vector classes // from java.util package import java.util.Enumeration; import java.util.Vector; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating a vector object Vector v = new Vector(); // Iterating over vector object for (int i = 0; i < 10; i++) v.addElement(i); // Printing elements in vector object System.out.println(v); // At beginning e(cursor) will point to // index just before the first element in v Enumeration e = v.elements(); // Checking the next element availability where // condition holds true till there is a single // element // remaining in the List while (e.hasMoreElements()) { // Moving cursor to next element int i = (Integer)e.nextElement(); // Print above elements in object System.out.print(i + ' '); } } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9>

Er zijn bepaalde beperkingen van de opsomming, die als volgt zijn:

• Opsomming is voor nalatenschap alleen klassen (Vector, Hashtabel). Het is dus geen universele iterator.
• Verwijderingsbewerkingen kunnen niet worden uitgevoerd met behulp van opsomming.
• Alleen iteratie in de voorwaartse richting is mogelijk.

Overeenkomsten tussen Java-opsomming en Iterator

• Beide zijn Java-cursors.
• Beide worden gebruikt om een ​​verzameling objectelementen één voor één te herhalen.
• Beide ondersteunen de READ- of Retrieval-bewerking.
• Beide zijn Unidirectionele Java-cursors, wat betekent dat ze alleen Forward Direction Iteration ondersteunen.

Verschillen tussen Java-opsomming en Iterator

De volgende tabel beschrijft de verschillen tussen Java Enumeration en Iterator:

3. LijstIterator

Het is alleen van toepassing op geïmplementeerde klassen van Lijstverzamelingen, zoals ArrayList, LinkedList, enz. Het biedt bidirectionele iteratie. ListIterator moet worden gebruikt als we elementen van List willen opsommen. Deze cursor heeft meer functionaliteit (methoden) dan iterator. ListIterator-object kan worden gemaakt door aan te roepen lijstIterator() methode aanwezig in de Lijstinterface.

Syntaxis

ListIterator ltr = l.  listIterator  ();>

Opmerking: Hier is l een willekeurig List-object, ltr is van het type. ListIterator-interface en verwijst naar l. De ListIterator-interface breidt de Iterator-interface uit. Alle drie de methoden van de Iterator-interface zijn dus beschikbaar voor ListIterator. Bovendien zijn er zes meer methoden.

1. Voorwaartse richting

1.1 heeftVolgende(): Retourneert waar als de iteratie meer elementen bevat

public boolean hasNext();>

1.2 volgende(): Hetzelfde als de next()-methode van Iterator. Retourneert het volgende element in de iteratie.

public Object next();>

1.3 volgendeIndex(): Retourneert de volgende elementindex of lijstgrootte als de lijstiterator zich aan het einde van de lijst bevindt.

public int nextIndex();>

2. Achterwaartse richting

2.1 heeftVorige(): Retourneert waar als de iteratie meer elementen bevat tijdens het achteruit doorlopen.

public boolean hasPrevious();>

2.2 vorige(): Retourneert het vorige element in de iteratie en kan gooien NoSuchElementException als er geen element meer aanwezig is.

public Object previous();>

2.3 vorigeIndex(): Retourneert de vorige elementindex of -1 als de lijstiterator aan het begin van de lijst staat,

array gesorteerd in Java

public int previousIndex();>

3. Andere methoden

3.1 verwijderen(): Hetzelfde als de methode remove() van Iterator. Verwijdert het volgende element in de iteratie.

gimp vervang kleur

public void remove();>

3.2 set(Objectobject): Vervangt het laatste element dat wordt geretourneerd door next() of previous() door het opgegeven element.

public void set(Object obj);>

3.3 toevoegen(Objectobject): Voegt het opgegeven element in de lijst in op de positie vóór het element dat zou worden geretourneerd door next()

public void add(Object obj);>

Het is duidelijk dat de drie methoden dat zijn LijstIterator erft van Iterator ( heeftVolgende() , volgende() , En verwijderen() ) doen precies hetzelfde in beide interfaces. De heeftVorige() en de voorgaande bewerkingen zijn exacte analogen van heeftVolgende() En volgende() . De eerstgenoemde bewerkingen hebben betrekking op het element vóór de (impliciete) cursor, terwijl de laatste betrekking heeft op het element na de cursor. Bij de vorige bewerking wordt de cursor naar achteren verplaatst, terwijl bij de volgende bewerking de cursor naar voren wordt verplaatst.

ListIterator heeft geen actueel element; de cursorpositie ligt altijd tussen het element dat zou worden geretourneerd door een aanroep naar vorig() en het element dat zou worden geretourneerd door een aanroep naar volgende().

1. instellen() methode kan 4 uitzonderingen genereren.

• Niet-ondersteundeOperationException: als de set-bewerking niet wordt ondersteund door deze lijstiterator
• ClassCastException: Als de klasse van het opgegeven element verhindert dat het aan deze lijst wordt toegevoegd
• Illegaal argumentUitzondering: Als een bepaald aspect van het opgegeven element verhindert dat het aan deze lijst wordt toegevoegd
• IllegaleStateException: Als noch volgende noch vorige zijn gebeld, of verwijderen of toevoegen zijn gebeld na de laatste oproep naar volgende of vorige

2. toevoegen() methode kan 3 uitzonderingen genereren.

• Niet-ondersteundeOperationException: Als de add-methode niet wordt ondersteund door deze lijstiterator
• ClassCastException: Als de klasse van het opgegeven element verhindert dat het aan deze lijst wordt toegevoegd
• Illegaal argumentUitzondering: Als een bepaald aspect van dit element verhindert dat het aan deze lijst wordt toegevoegd

Voorbeeld

// Java program to demonstrate ListIterator // Importing ArrayList and List iterator classes // from java.util package import java.util.ArrayList; import java.util.ListIterator; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating an object of ArrayList class ArrayList al = new ArrayList(); // Iterating over Arraylist object for (int i = 0; i < 10; i++) // Adding elements to the Arraylist object al.add(i); // Print and display all elements inside object // created above System.out.println(al); // At beginning ltr(cursor) will point to // index just before the first element in al ListIterator ltr = al.listIterator(); // Checking the next element availability while (ltr.hasNext()) { // Moving cursor to next element int i = (Integer)ltr.next(); // Getting even elements one by one System.out.print(i + ' '); // Changing even numbers to odd and // adding modified number again in // iterator if (i % 2 == 0) { // Change to odd i++; // Set method to change value ltr.set(i); // To add ltr.add(i); } } // Print and display statements System.out.println(); System.out.println(al); } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9 [1, 1, 1, 3, 3, 3, 5, 5, 5, 7, 7, 7, 9, 9, 9]>

Opmerking: Op dezelfde manier zijn er bepaalde beperkingen met ListIterator . Het is de krachtigste iterator, maar is alleen van toepassing op door List geïmplementeerde klassen, dus het is geen universele iterator.

Belangrijke punten

1. Houd er rekening mee dat elke iteratorverwijzing in eerste instantie naar de index verwijst net vóór de index van het eerste element in een verzameling.
2. We maken geen objecten van Enumeration, Iterator, ListIterator omdat het interfaces zijn. We gebruiken methoden zoals elements(), iterator(), listIterator() om objecten te maken. Deze methoden hebben een anonieme Innerlijke klasse dat de respectieve interfaces uitbreidt en dit klasseobject retourneert.

Opmerking: De $ symbool in de naam van de referentieklasse is een bewijs dat het concept van innerlijke klassen wordt gebruikt en dat deze klasseobjecten worden gemaakt.

Dit kan worden geverifieerd met de onderstaande code. Voor meer informatie over innerlijke klasse, zie

// Java program to demonstrate iterators references // Importing required classes from java.util package import java.util.Enumeration; import java.util.Iterator; import java.util.ListIterator; import java.util.Vector; // Main class public class GFG { // Main driver method public static void main(String[] args) { // Creating an object of Vector class Vector v = new Vector(); // Creating three iterators Enumeration e = v.elements(); Iterator itr = v.iterator(); ListIterator ltr = v.listIterator(); // Print class names of iterators // using getClass() and getName() methods System.out.println(e.getClass().getName()); System.out.println(itr.getClass().getName()); System.out.println(ltr.getClass().getName()); } }>

java.util.Vector java.util.Vector$Itr java.util.Vector$ListItr>

Uitleg

In Java is een iterator een interface die wordt gebruikt om één voor één door een verzameling objecten te bladeren. Het wordt gebruikt om elke op verzamelingen gebaseerde datastructuur te doorlopen, inclusief arrays, lijsten, sets en kaarten.

Een iterator heeft drie hoofdmethoden die worden gebruikt om door de verzameling te lopen:

• hasNext() – Deze methode controleert of er een ander element in de verzameling is waarover kan worden herhaald.
• next() – Deze methode retourneert het volgende element in de verzameling.
• remove() – Deze methode verwijdert het huidige element uit de verzameling.
  

De Iterator-interface is een onderdeel van het Java Collection Framework en wordt geïmplementeerd door de klassen die de verschillende soorten collecties vertegenwoordigen.

Programma

import java.util.ArrayList; import java.util.Iterator; public class IteratorExample { public static void main(String[] args) { ArrayListnamen = nieuwe ArrayList(); namen.add('Alice'); namen.add('Bob'); namen.add('Charlie'); namen.add('David'); // Een iterator maken voor de namenlijst Iteratoriterator = namen.iterator(); // Herhaal de namenlijst met behulp van de iterator while (iterator.hasNext()) { String name = iterator.next(); Systeem.out.println(naam); } } }>

Alice Bob Charlie David>

In dit voorbeeld hebben we een ArrayList met tekenreeksen gemaakt en er vier namen aan toegevoegd. Vervolgens hebben we een iterator voor de lijst gemaakt met behulp van de iterator() -methode van de klasse ArrayList. We hebben de methode hasNext() gebruikt om te controleren of er meer elementen in de lijst zijn waarover moet worden herhaald, en de methode next() om het volgende element in de lijst te krijgen. We hebben elk element afgedrukt met behulp van de System.out.println() -methode.

Het gebruik van een iterator om door een verzameling te lopen is een handige en efficiënte manier om door de verzameling te itereren, omdat de verzameling hierdoor kan worden herhaald zonder de interne structuur van de verzameling te kennen. Het maakt het ook mogelijk om elementen uit de verzameling te verwijderen terwijl u eroverheen loopt.

Voordelen van Iterator in Java:

• De Iterator is een eenvoudige en gebruiksvriendelijke interface waarmee we een verzameling kunnen doorlopen zonder de onderliggende implementatie bloot te leggen.
• De Iterator is een efficiënte manier om een ​​verzameling te herhalen, vooral als we over een grote hoeveelheid gegevens beschikken.
• De Iterator biedt een veilige manier om elementen uit een verzameling te verwijderen tijdens iteratie zonder gelijktijdige wijzigingsuitzonderingen te veroorzaken.
• De Iterator-interface wordt geïmplementeerd door alle collectieklassen in Java, zodat we dezelfde code kunnen gebruiken om verschillende soorten collecties te doorlopen.

Nadelen van Iterator in Java:

Er zijn bepaalde nadelen aan het gebruik van Iterator in Java, zoals hieronder vermeld:

• De Iterator is een unidirectionele interface, wat betekent dat we alleen vooruit kunnen gaan door een verzameling. We kunnen niet achteruit gaan of naar een specifiek element springen.
• De Iterator is niet thread-safe, dus we kunnen hem niet gebruiken om een ​​verzameling in een omgeving met meerdere threads te herhalen zonder de juiste synchronisatie.
• De Iterator biedt geen enkel mechanisme om elementen te wijzigen tijdens het herhalen van een verzameling, afgezien van het verwijderen van elementen. Als we elementen moeten wijzigen, moeten we andere interfaces gebruiken, zoals ListIterator of een eenvoudige for-lus.