En Java-markör är en Iterator som används för att iterera eller gå igenom eller hämta en samlings- eller strömobjekts element en efter en. I den här artikeln kommer vi att lära oss om Java Iterators och det fungerar.

Typer av markörer i Java

Det finns tre markörer i Java som nämns nedan:

1. Iterator
2. Uppräkning
3. ListIterator

Notera: SplitIterator kan också betraktas som en markör eftersom det endast är en typ av Iterator.

1. Iterator

Iteratorer i Java används i Samlingsram för att hämta element en efter en. Det är en universell iterator som vi kan tillämpa den på vilket samlingsobjekt som helst. Genom att använda Iterator kan vi utföra både läs- och borttagningsoperationer. Det är en förbättrad version av Enumeration med den extra funktionen att ta bort ett element.

Iterator måste användas när vi vill räkna upp element i alla Collection framework implementerade gränssnitt som Set, List, Queue, Deque och alla implementerade klasser av kartgränssnitt. Iteratorn är endast markören tillgänglig för hela samlingsramverket. Ett iteratorobjekt kan skapas genom att anropa iterator() metod som finns i samlingsgränssnittet.

Syntax

Iterator itr = c.  iterator  ();>

Notera: Här är c ​​vilket samlingsobjekt som helst. itr är av typen Iterator-gränssnitt och hänvisar till c.

java-anslutning

Metoder för iteratorgränssnitt i Java

Iteratorgränssnittet definierar tre metoder som listas nedan:

1. hasNext(): Returnerar sant om iterationen har fler element.

public boolean hasNext();>

2. nästa(): Returnerar nästa element i iterationen. Det kastar NoSuchElementException om inget mer element är närvarande.

public Object next();>

3. ta bort(): Tar bort nästa element i iterationen. Denna metod kan endast anropas en gång per anrop till next().

public void remove();>

Notera: avlägsna() metod kan ge två undantag nämligen enligt följande:

• UnsupportedOperationException : Om borttagningsåtgärden inte stöds av denna iterator
• IllegalStateException : Om nästa metod ännu inte har anropats, eller borttagningsmetoden redan har anropats efter det senaste anropet till nästa metod.

Hur fungerar Java Iterator internt?

I det här avsnittet kommer vi att försöka förstå hur Java Iterator och dess metoder fungerar internt. Låt oss ta följande LinkedList-objekt för att förstå denna funktionalitet.

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

Låt oss nu skapa ett Iterator-objekt på List-objektet som visas nedan:

Iterator citiesIterator = cities.iterator();>

Iteratorn för cityIteartor kommer att se ut så här –

Här pekar Iterators markör före det första elementet i listan.

Nu kör vi följande kodavsnitt.

mylivecricket.in

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

När vi kör ovanstående kodavsnitt pekar Iterators markör på det första elementet i listan som visas i diagrammet ovan.

Nu kör vi följande kodavsnitt.

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

När vi kör ovanstående kodavsnitt pekar Iterators markör på det andra elementet i listan som visas i diagrammet ovan. Gör denna process för att nå Iteratorns markör till slutet av listan.

Efter att ha läst det sista elementet, om vi kör kodavsnittet nedan, returnerar det ett falskt värde.

citiesIterator.hasNext();>

Eftersom Iterators markör pekar på efter det sista elementet i listan, returnerar hasNext()-metoden ett falskt värde.

Notera: Efter att ha observerat alla dessa diagram kan vi säga att Java Iterator endast stöder Forward Direction Iteration som visas i diagrammet nedan. Så den är också känd som Uni-Directional Cursor.

Exempel

// 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 = ny ArrayList (); // Itererar över listan för (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(); // Kontrollera nästa element där // villkor gäller tills det finns ett enda element // i listan med metoden hasnext() while (itr.hasNext()) { // Flytta markören till nästa element int i = itr.next( ); // Få element ett efter ett System.out.print(i + ' '); // Ta bort udda element if (i % 2 != 0) itr.remove(); } // Kommando för nästa rad System.out.println(); // Skriva ut elementen inuti objektet 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

Spliteratorer, liksom andra iteratorer, är till för att korsa elementen i en källa. En källa kan vara en Samling , en IO-kanal eller en generatorfunktion. Den ingår i JDK 8 för stöd för effektiv parallelltraversering (parallell programmering) utöver sekventiell traversering. Java Spliterator-gränssnitt är en intern iterator som delar upp strömmen i mindre delar. Dessa mindre delar kan bearbetas parallellt.

Notera: I verkliga programmering behöver vi kanske aldrig använda Spliterator direkt. Under normal drift kommer den att bete sig exakt likadant som Java Iterator.

Fördelar med Java Iterator

• Vi kan använda den för alla samlingsklasser.
• Den stöder både LÄS- och BORT-operationer.
• Det är ett Universal Cursor for Collection API.
• Metodnamn är enkla och lätta att använda dem.

Begränsningar för Java Iterator

Det finns också vissa begränsningar för Iterator som listas enligt följande:

• I CRUD Operations stöder den INTE CREATE och UPDATE operationer.
• Den stöder endast iteration i riktning framåt som är en enkelriktad iterator.
• Jämför med Spliterator, den stöder INTE itererande element parallella vilket betyder att den endast stöder sekventiell iteration.
• Jämfört med Spliterator, den stöder INTE bättre prestanda för att iterera stora datamängder.

2. Uppräkning

Det är ett gränssnitt som används för att hämta element av äldre samlingar (Vector, Hashtable). Uppräkning är den första iteratorn som finns från JDK 1.0, vilor ingår i JDK 1.2 med mer funktionalitet. Uppräkningar används också för att specificera ingångsströmmarna till en SequenceInputStream . Vi kan skapa ett uppräkningsobjekt genom att anropa elements() metod för vektorklassen på vilket vektorobjekt som helst

Syntax

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

Det finns två metoder i uppräkningsgränssnittet nämligen:

1. public boolean hasMoreElements(): Denna metod testar om denna uppräkning innehåller fler element eller inte.

2. public Object nextElement(): Denna metod returnerar nästa element i denna uppräkning. Den kastar NoSuchElementException om det inte finns fler element

Exempel

// 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>

Det finns vissa begränsningar för uppräkning som är följande:

• Uppräkning är för arv endast klasser (vektor, hashtabell). Därför är det inte en universell iterator.
• Ta bort operationer kan inte utföras med uppräkning.
• Endast iterering framåt i riktning är möjlig.

Likheter mellan Java Enumeration och Iterator

• Båda är Java-markörer.
• Båda används för att iterera en samling objektelement en efter en.
• Båda stöder READ eller Retrieval operation.
• Båda är enkelriktade Java-markörer vilket innebär att endast stöd för Forward Direction Iteration.

Skillnader mellan Java Enumeration och Iterator

Följande tabell beskriver skillnaderna mellan Java Enumeration och Iterator:

3. ListIterator

Det är endast tillämpligt för listsamlingsimplementerade klasser som ArrayList, LinkedList, etc. Det ger dubbelriktad iteration. ListIterator måste användas när vi vill räkna upp element i List. Den här markören har fler funktioner (metoder) än iterator. ListIterator-objekt kan skapas genom att anropa listIterator() metod som finns i listgränssnittet.

Syntax

ListIterator ltr = l.  listIterator  ();>

Notera: Här är l vilket Listobjekt som helst, ltr är av typen. ListIterator-gränssnittet och hänvisar till l. ListIterator-gränssnittet utökar Iterator-gränssnittet. Så alla tre metoderna för Iterator-gränssnitt är tillgängliga för ListIterator. Dessutom finns det sex fler metoder.

1. Riktning framåt

1.1 hasNext(): Returnerar sant om iterationen har fler element

public boolean hasNext();>

1.2 nästa(): Samma som metoden next() för Iterator. Returnerar nästa element i iterationen.

public Object next();>

1.3 nextIndex(): Returnerar nästa elementindex eller liststorlek om listiteratorn är i slutet av listan.

public int nextIndex();>

2. Bakåtriktning

2.1 hasPrevious(): Returnerar sant om iterationen har fler element medan den går bakåt.

public boolean hasPrevious();>

2.2 föregående(): Returnerar föregående element i iterationen och kan kasta NoSuchElementException om inget mer element är närvarande.

public Object previous();>

2.3 föregåendeIndex(): Returnerar föregående elementindex eller -1 om listiteratorn är i början av listan,

alfabet med siffror

public int previousIndex();>

3. Andra metoder

3.1 ta bort(): Samma som remove()-metoden för Iterator. Tar bort nästa element i iterationen.

public void remove();>

3.2 set(Objekt objekt): Ersätter det sista elementet som returneras av next() eller previous() med det angivna elementet.

public void set(Object obj);>

3.3 add(Object obj): Infogar det angivna elementet i listan vid positionen före elementet som skulle returneras av next()

public void add(Object obj);>

Klart, de tre metoder som ListIterator ärver från Iterator ( hasNext() , Nästa() , och avlägsna() ) gör exakt samma sak i båda gränssnitten. De hasPrevious() och de tidigare operationerna är exakta analoger av hasNext() och Nästa() . De förra operationerna hänvisar till elementet före den (implicita) markören, medan de senare hänvisar till elementet efter markören. Föregående operation flyttar markören bakåt, medan nästa flyttar den framåt.

ListIterator har inget aktuellt element; dess markörposition ligger alltid mellan elementet som skulle returneras av ett anrop till tidigare() och elementet som skulle returneras av ett anrop till Nästa().

1. set() Metoden kan ge 4 undantag.

• UnsupportedOperationException: om inställningsoperationen inte stöds av denna listiterator
• ClassCastException: Om klassen för det angivna elementet hindrar det från att läggas till i den här listan
• IllegalArgumentException: Om någon aspekt av det angivna elementet hindrar det från att läggas till i den här listan
• IllegalStateException: Om varken nästa eller föregående har anropats, eller ta bort eller lägg har anropats efter det senaste anropet till nästa eller föregående

2. add() Metoden kan ge 3 undantag.

• UnsupportedOperationException: Om add-metoden inte stöds av denna listiterator
• ClassCastException: Om klassen för det angivna elementet hindrar det från att läggas till i den här listan
• IllegalArgumentException: Om någon aspekt av detta element hindrar det från att läggas till i den här listan

Exempel

// 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]>

Notera: På samma sätt finns det vissa begränsningar med ListIterator . Det är den mest kraftfulla iteratorn men den är bara tillämplig för List-implementerade klasser, så det är inte en universell iterator.

byt namn på linux-mappen

Viktiga punkter

1. Observera att till en början kommer varje iteratorreferens att peka på indexet precis före indexet för det första elementet i en samling.
2. Vi skapar inte objekt med Enumeration, Iterator, ListIterator eftersom de är gränssnitt. Vi använder metoder som elements(), iterator(), listIterator() för att skapa objekt. Dessa metoder har en anonym Inre klass som utökar respektive gränssnitt och returnerar detta klassobjekt.

Notera: De $ symbol i referensklassnamn är ett bevis på att begreppet inre klasser används och dessa klassobjekt skapas.

Detta kan verifieras med koden nedan. Se mer om inre klass

// 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>

Förklaring

I Java är en iterator ett gränssnitt som används för att gå igenom en samling objekt ett efter ett. Den används för att iterera genom alla samlingsbaserade datastrukturer, inklusive arrayer, listor, uppsättningar och kartor.

En iterator har tre huvudmetoder som används för att gå igenom samlingen:

• hasNext() – Den här metoden kontrollerar om det finns ett annat element i samlingen som kan itereras över.
• next() – Denna metod returnerar nästa element i samlingen.
• remove() – Denna metod tar bort det aktuella elementet från samlingen.
  

Iterator-gränssnittet är en del av Java Collection Framework, och det implementeras av klasserna som representerar de olika typerna av samlingar.

Program

import java.util.ArrayList; import java.util.Iterator; public class IteratorExample { public static void main(String[] args) { ArrayListnamn = ny ArrayList(); names.add('Alice'); names.add('Bob'); names.add('Charlie'); names.add('David'); // Skapa en iterator för namnlistan Iteratoriterator = namn.iterator(); // Itererar över namnlistan med iteratorn while (iterator.hasNext()) { String name = iterator.next(); System.out.println(namn); } } }>

Alice Bob Charlie David>

I det här exemplet har vi skapat en ArrayList med strängar och lagt till fyra namn till den. Vi har sedan skapat en iterator för listan med metoden iterator() i klassen ArrayList. Vi har använt metoden hasNext() för att kontrollera om det finns fler element i listan som ska itereras över, och metoden next() för att få nästa element i listan. Vi har skrivit ut varje element med metoden System.out.println().

Att använda en iterator för att gå igenom en samling är ett bekvämt och effektivt sätt att iterera genom samlingen eftersom det gör att samlingen kan itereras utan att känna till samlingens interna struktur. Det gör det också möjligt att ta bort element från samlingen medan man itererar över den.

Fördelar med Iterator i Java:

• Iteratorn är ett enkelt och lättanvänt gränssnitt som låter oss gå igenom en samling utan att avslöja dess underliggande implementering.
• Iteratorn är ett effektivt sätt att iterera över en samling, speciellt när vi har en stor mängd data.
• Iteratorn tillhandahåller ett säkert sätt att ta bort element från en samling under iteration utan att orsaka några samtidiga modifieringsundantag.
• Iterator-gränssnittet är implementerat av alla samlingsklasser i Java, så vi kan använda samma kod för att iterera över olika typer av samlingar.

Nackdelar med Iterator i Java:

Det finns vissa nackdelar med att använda Iterator i Java som nämns nedan:

• Iteratorn är ett enkelriktat gränssnitt, vilket betyder att vi bara kan gå framåt genom en samling. Vi kan inte gå bakåt eller hoppa till ett specifikt element.
• Iteratorn är inte trådsäker, så vi kan inte använda den för att iterera över en samling i en flertrådig miljö utan korrekt synkronisering.
• Iteratorn tillhandahåller ingen mekanism för att modifiera element medan den itererar över en samling, förutom att ta bort element. Om vi ​​behöver modifiera element måste vi använda andra gränssnitt som ListIterator eller en enkel för loop.