En Java-markør er en iterator, der bruges til at iterere eller krydse eller hente en samling eller stream-objekts elementer én efter én. I denne artikel lærer vi om Java Iterators, og det virker.

Typer af markører i Java

Der er tre markører i Java som nævnt nedenfor:

1. Iterator
2. Optælling
3. ListIterator

Bemærk: SplitIterator kan også betragtes som en markør, da det kun er en type Iterator.

1. Iterator

Iteratorer i Java bruges i Indsamlingsramme at hente elementer én efter én. Det er en universel iterator, da vi kan anvende den på ethvert samlingsobjekt. Ved at bruge Iterator kan vi udføre både læse- og fjernehandlinger. Det er en forbedret version af Enumeration med den ekstra funktionalitet at fjerne et element.

Iterator skal bruges, når vi ønsker at opregne elementer i alle Collection framework implementerede grænseflader som Set, List, Queue, Deque og alle implementerede klasser af kortgrænseflade. Iteratoren er kun markøren tilgængelig for hele samlingsrammen. Et iteratorobjekt kan oprettes ved at kalde iterator() metode til stede i samlingsgrænsefladen.

Syntaks

Iterator itr = c.  iterator  ();>

Bemærk: Her er c ethvert samlingsobjekt. itr er af typen Iterator-interface og henviser til c.

.lig med java

Metoder til iterator-interface i Java

Iteratorgrænsefladen definerer tre metoder som anført nedenfor:

1. hasNext(): Returnerer sand, hvis iterationen har flere elementer.

public boolean hasNext();>

2. næste(): Returnerer det næste element i iterationen. Det kaster NoSuchElementException hvis der ikke er mere element til stede.

public Object next();>

3. fjern(): Fjerner det næste element i iterationen. Denne metode kan kun kaldes én gang pr. kald til next().

public void remove();>

Bemærk: fjerne() metode kan give to undtagelser, nemlig som følger:

• Ikke understøttet OperationException : Hvis fjernelsesoperationen ikke understøttes af denne iterator
• IllegalStateException : Hvis den næste metode endnu ikke er blevet kaldt, eller fjernmetoden allerede er blevet kaldt efter det sidste kald til den næste metode.

Hvordan fungerer Java Iterator internt?

I dette afsnit vil vi forsøge at forstå, hvordan Java Iterator og dets metoder fungerer internt. Lad os tage følgende LinkedList-objekt for at forstå denne funktionalitet.

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

Lad os nu oprette et Iterator-objekt på List-objektet som vist nedenfor:

Iterator citiesIterator = cities.iterator();>

cityIteartor-iteratoren vil se sådan ud –

Her peger Iterators markør før det første element i listen.

Nu kører vi følgende kodestykke.

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

Når vi kører ovenstående kodestykke, peger Iterators markør på det første element på listen som vist i ovenstående diagram.

pandaer og numpy

Nu kører vi følgende kodestykke.

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

Når vi kører ovenstående kodestykke, peger Iterators markør på det andet element på listen som vist i ovenstående diagram. Udfør denne proces for at nå Iteratorens markør til slutelementet på listen.

Efter at have læst det sidste element, hvis vi kører nedenstående kodestykke, returnerer det en falsk værdi.

citiesIterator.hasNext();>

Da Iterators markør peger på efter det sidste element i listen, returnerer hasNext() metoden en falsk værdi.

Bemærk: Efter at have observeret alle disse diagrammer, kan vi sige, at Java Iterator kun understøtter Forward Direction Iteration som vist i nedenstående diagram. Så det er også kendt som Uni-Directional Cursor.

Eksempel

// 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 (); // Iteration over listen for (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(); // Kontrollerer det næste element, hvor // betingelse gælder, indtil der er et enkelt element // i listen ved hjælp af hasnext()-metoden while (itr.hasNext()) { // Flytter markøren til næste element int i = itr.next( ); // At få elementer ét efter ét System.out.print(i + ' '); // Fjernelse af ulige elementer if (i % 2 != 0) itr.remove(); } // Kommando for næste linje System.out.println(); // Udskrivning af elementerne inde i 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 er ligesom andre iteratorer til at krydse elementerne i en kilde. En kilde kan være en Kollektion , en IO-kanal eller en generatorfunktion. Det er inkluderet i JDK 8 til understøttelse af effektiv parallel traversal (parallel programmering) ud over sekventiel traversal. Java Spliterator interface er en intern iterator, der deler strømmen op i mindre dele. Disse mindre dele kan bearbejdes parallelt.

Bemærk: I virkelighedens programmering behøver vi måske aldrig bruge Spliterator direkte. Under normal drift vil den opføre sig nøjagtigt det samme som Java Iterator.

Fordele ved Java Iterator

• Vi kan bruge det til enhver samlingsklasse.
• Det understøtter både LÆS og FJERN operationer.
• Det er en Universal Cursor for Collection API.
• Metodenavne er enkle og nemme at bruge dem.

Begrænsninger af Java Iterator

Der er også visse begrænsninger af Iterator, som er angivet som følger:

• I CRUD Operations understøtter den IKKE CREATE og UPDATE operationer.
• Den understøtter kun fremadgående iteration, der er en ensrettet iterator.
• Sammenlignet med Spliterator, understøtter den IKKE itererende elementer parallelt, hvilket betyder, at den kun understøtter sekventiel iteration.
• Sammenlignet med Spliterator, understøtter den IKKE bedre ydeevne til at gentage store mængder data.

2. Opregning

Det er en grænseflade, der bruges til at hente elementer af ældre samlinger (Vector, Hashtable). Enumeration er den første iterator til stede fra JDK 1.0, hviler er inkluderet i JDK 1.2 med mere funktionalitet. Optællinger bruges også til at specificere inputstrømmene til en SequenceInputStream . Vi kan oprette et Enumeration-objekt ved at kalde elementer() metode for vektorklassen på ethvert vektorobjekt

Syntaks

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

Der er to metoder i Enumeration-grænsefladen, nemlig:

1. offentlig boolean hasMoreElements(): Denne metode tester, om denne opregning indeholder flere elementer eller ej.

2. offentligt objekt næsteElement(): Denne metode returnerer det næste element i denne opregning. Det kaster NoSuchElementException, hvis der ikke er mere element til stede

Eksempel

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

Der er visse begrænsninger for opregning, som er som følger:

• Optælling er for eftermæle kun klasser (vektor, hashtabel). Derfor er det ikke en universel iterator.
• Fjernhandlinger kan ikke udføres ved hjælp af enumeration.
• Kun fremadgående iteration er mulig.

Ligheder mellem Java Enumeration og Iterator

• Begge er Java-markører.
• Begge bruges til at iterere en samling af objektelementer én efter én.
• Begge understøtter READ eller Retrieval operation.
• Begge er ensrettede Java-markører, hvilket betyder, at de kun understøtter Forward Direction Iteration.

Forskelle mellem Java Enumeration og Iterator

Følgende tabel beskriver forskellene mellem Java Enumeration og Iterator:

3. ListIterator

Det er kun anvendeligt for listesamling implementerede klasser som ArrayList, LinkedList osv. Det giver tovejs iteration. ListIterator skal bruges, når vi ønsker at opregne elementer i List. Denne markør har flere funktioner (metoder) end iterator. ListIterator-objekt kan oprettes ved at kalde listIterator() metode til stede i List-grænsefladen.

Syntaks

ListIterator ltr = l.  listIterator  ();>

Bemærk: Her er l et hvilket som helst List-objekt, ltr er af typen. ListIterator interface og henviser til l. ListIterator-grænsefladen udvider Iterator-grænsefladen. Så alle tre metoder til Iterator-interface er tilgængelige for ListIterator. Derudover er der seks flere metoder.

1. Retning fremad

1.1 hasNext(): Returnerer sand, hvis iterationen har flere elementer

public boolean hasNext();>

1.2 næste(): Samme som next() metode i Iterator. Returnerer det næste element i iterationen.

public Object next();>

1.3 næste indeks(): Returnerer det næste elementindeks eller listestørrelse, hvis listeiteratoren er i slutningen af ​​listen.

public int nextIndex();>

2. Retning bagud

2.1 hasPrevious(): Returnerer sand, hvis iterationen har flere elementer, mens den går baglæns.

public boolean hasPrevious();>

2.2 forrige(): Returnerer det forrige element i iterationen og kan kaste NoSuchElementException hvis der ikke er mere element til stede.

public Object previous();>

2.3 forrige indeks(): Returnerer det forrige elementindeks eller -1, hvis listeiteratoren er i begyndelsen af ​​listen,

array sorteret i java

public int previousIndex();>

3. Andre metoder

3.1 fjern(): Samme som remove()-metoden i Iterator. Fjerner det næste element i iterationen.

public void remove();>

3.2 sæt(Objektobjekt): Erstatter det sidste element returneret af next() eller previous() med det angivne element.

public void set(Object obj);>

3.3 add(Object obj): Indsætter det angivne element i listen på positionen før det element, der ville blive returneret af next()

public void add(Object obj);>

Det er klart, de tre metoder, der ListIterator arver fra Iterator ( hasNext() , Næste() , og fjerne() ) gør nøjagtig det samme i begge grænseflader. Det harForrige() og de tidligere operationer er nøjagtige analoger af hasNext() og Næste() . De førstnævnte operationer refererer til elementet før den (implicitte) markør, hvorimod sidstnævnte refererer til elementet efter markøren. Den forrige handling flytter markøren tilbage, mens den næste flytter den fremad.

ListIterator har ikke noget aktuelt element; dens markørposition ligger altid mellem det element, der ville blive returneret ved et kald til Tidligere() og det element, der ville blive returneret ved et opkald til Næste().

1. sæt() metode kan give 4 undtagelser.

• Unsupported OperationException: hvis den indstillede handling ikke understøttes af denne listeiterator
• ClassCastException: Hvis klassen af ​​det angivne element forhindrer det i at blive tilføjet til denne liste
• UlovligArgumentundtagelse: Hvis et aspekt af det angivne element forhindrer det i at blive tilføjet til denne liste
• IllegalStateException: Hvis hverken næste eller forrige er blevet kaldt, eller fjerne eller tilføje er blevet kaldt efter sidste opkald til næste eller forrige

2. tilføje() metode kan give 3 undtagelser.

• Unsupported OperationException: Hvis tilføjelsesmetoden ikke understøttes af denne listeiterator
• ClassCastException: Hvis klassen for det angivne element forhindrer det i at blive tilføjet til denne liste
• UlovligArgumentundtagelse: Hvis et aspekt af dette element forhindrer det i at blive tilføjet til denne liste

Eksempel

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

Bemærk: På samme måde er der visse begrænsninger med ListIterator . Det er den mest kraftfulde iterator, men den er kun anvendelig for List-implementerede klasser, så det er ikke en universel iterator.

Vigtige pointer

1. Bemærk venligst, at til at begynde med vil enhver iteratorreference pege på indekset lige før indekset for det første element i en samling.
2. Vi opretter ikke objekter med Enumeration, Iterator, ListIterator, fordi de er grænseflader. Vi bruger metoder som elements(), iterator(), listIterator() til at skabe objekter. Disse metoder har en anonym Indre klasse der udvider respektive grænseflader og returnerer dette klasseobjekt.

Bemærk: Det $ symbol i reference klassenavn er et bevis på, at begrebet indre klasser bruges, og disse klasseobjekter er oprettet.

simkort indsat men ingen service android

Dette kan verificeres med nedenstående kode. For mere om indre klasse se

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

Forklaring

I Java er en iterator en grænseflade, der bruges til at krydse gennem en samling af objekter én efter én. Det bruges til at iterere gennem enhver samlingsbaseret datastruktur, herunder arrays, lister, sæt og kort.

En iterator har tre hovedmetoder, der bruges til at krydse samlingen:

• hasNext() – Denne metode kontrollerer, om der er et andet element i samlingen, der kan gentages.
• next() – Denne metode returnerer det næste element i samlingen.
• remove() – Denne metode fjerner det aktuelle element fra samlingen.
  

Iterator-grænsefladen er en del af Java Collection Framework, og den implementeres af de klasser, der repræsenterer de forskellige typer af samlinger.

Program

import java.util.ArrayList; import java.util.Iterator; public class IteratorExample { public static void main(String[] args) { ArrayListnavne = ny ArrayList(); names.add('Alice'); names.add('Bob'); names.add('Charlie'); names.add('David'); // Oprettelse af en iterator til navnelisten Iteratoriterator = navne.iterator(); // Iteration over navnelisten ved hjælp af iteratoren while (iterator.hasNext()) { String name = iterator.next(); System.out.println(navn); } } }>

Alice Bob Charlie David>

I dette eksempel har vi lavet en ArrayList af strenge og tilføjet fire navne til den. Vi har derefter oprettet en iterator til listen ved hjælp af iterator()-metoden i ArrayList-klassen. Vi har brugt hasNext()-metoden til at kontrollere, om der er flere elementer på listen, der skal gentages, og next()-metoden til at få det næste element på listen. Vi har udskrevet hvert element ved hjælp af System.out.println() metoden.

At bruge en iterator til at krydse gennem en samling er en bekvem og effektiv måde at iterere gennem samlingen på, fordi det gør det muligt at gentage samlingen uden at kende den interne struktur af samlingen. Det giver også mulighed for at fjerne elementer fra samlingen, mens du itererer over den.

Fordele ved Iterator i Java:

• Iteratoren er en enkel og nem at bruge grænseflade, der giver os mulighed for at krydse en samling uden at afsløre dens underliggende implementering.
• Iteratoren er en effektiv måde at iterere over en samling, især når vi har en stor mængde data.
• Iteratoren giver en sikker måde at fjerne elementer fra en samling under iteration uden at forårsage samtidige ændringer.
• Iterator-grænsefladen er implementeret af alle samlingsklasserne i Java, så vi kan bruge den samme kode til at iterere over forskellige typer samlinger.

Ulemper ved Iterator i Java:

Der er visse ulemper ved at bruge Iterator i Java som nævnt nedenfor:

• Iteratoren er en ensrettet grænseflade, hvilket betyder, at vi kun kan bevæge os fremad gennem en samling. Vi kan ikke bevæge os tilbage eller hoppe til et bestemt element.
• Iteratoren er ikke trådsikker, så vi kan ikke bruge den til at iterere over en samling i et multi-threaded miljø uden ordentlig synkronisering.
• Iteratoren giver ikke nogen mekanisme til at ændre elementer, mens den itererer over en samling, bortset fra at fjerne elementer. Hvis vi har brug for at ændre elementer, skal vi bruge andre grænseflader som ListIterator eller en simpel for loop.