Menu

Java Iterator: Lær at bruge Iteratorer i Java med eksempler

  • Vigtigste
  • Andet
  • Java Iterator: Lær at bruge Iteratorer i Java med eksempler

java iterator learn use iterators java with examples

Prøv Vores Instrument Til At Fjerne Problemer

I denne vejledning lærer vi om itteratorer i Java. Vi vil have detaljeret diskussion om Iterator- og ListIterator-grænseflader i Java:

Vi udforskede alt om Java Collection Framework og dens forskellige understøttende grænseflader og klasser i en af ​​vores tidligere tutorials.

Når du har en samling, vil du have adgang til dens elementer, tilføje / fjerne eller behandle elementerne. For at udføre al denne behandling gennem et Java-program, skal du være i stand til at krydse gennem den samling, du bruger. Det er her, iteratoren kommer ind i billedet.

Java Iterator

Hvad du lærer:

Hvad er en Java Iterator?

I Java er en Iterator en konstruktion, der bruges til at krydse eller gå gennem samlingen.

For at bruge en Iterator skal du hente iteratorobjektet ved hjælp af ' iterator () ” metode til indsamlingsgrænsefladen. Java Iterator er et samlingsrammerinterface og er en del af pakken “java.util”. Ved hjælp af Java Iterator kan du gentage gennem samling af objekter.

Java Iterator-interface erstatter tælleren, der blev brugt tidligere til at gå igennem nogle enkle samlinger som vektorer.

De største forskelle mellem Java Iterator og Enumerator er:

  • Betydelig forbedring af metodenavne.
  • Du kan fjerne metodeelementer fra samlingen, der gennemkøres, ved hjælp af en iterator.

I denne vejledning vil vi diskutere detaljerne i Iterator-interface og ListIterator-interface, der er en tovejs-interface.

Iteratortyper

  • Tæller
  • Iterator
  • ListIterator

En tæller bruges sjældent nu. Derfor vil vi i vores tutorial-serie fokusere på Iterator- og ListIterator-grænseflader.

Iterator-interface i Java

Iterator-grænsefladen i Java er en del af rammerne for samlinger i pakken 'java.util' og er en markør, der kan bruges til at gennemgå samlingen af ​​objekter.

Iterator-grænsefladen har følgende hovedegenskaber:

  • Iterator-grænsefladen er tilgængelig fra Java 1.2-samlingsrammen og fremefter.
  • Det krydser samlingen af ​​objekter en efter en.
  • Populært kendt som “Universal Java Cursor”, da det fungerer med alle samlinger.
  • Denne grænseflade understøtter 'læse' og 'fjerne' handlinger, dvs. du kan fjerne et element under en iteration ved hjælp af iteratoren.

Generel repræsentation af Iterator-grænsefladen er angivet nedenfor:

Repræsentation af iteratorgrænsefladen

Lad os derefter se på Iterator-metoderne, der er anført ovenfor.

Iteratormetoder

Iterator-grænsefladen understøtter følgende metoder:

# 1) Næste ()

Prototype: E næste ()
Parametre: ingen parametre
Returtype: E -> element
Beskrivelse: Returnerer det næste element i samlingen.

Hvis iteration (samling) ikke har flere elementer, så kaster den NoSuchElementException .

# 2) hasNext ()

Prototype: boolsk hasNext ()
Parametre: NIL
Returtype: true => der er elementer i samlingen.

Falsk => ikke flere elementer

Beskrivelse: Funktionen hasNext () kontrollerer, om der er flere elementer i samlingen, der åbnes ved hjælp af en iterator. Hvis der ikke er flere elementer, kalder du ikke den næste () metode. Med andre ord kan denne funktion bruges til at afgøre, om den næste () metode skal kaldes.

# 3) fjern ()

Prototype: ugyldig fjern ()
Parametre: NIL
Returtype: NIL

Beskrivelse: Fjerner det sidste element, der returneres af iteratoren, der gentager over den underliggende samling. Fjern () -metoden kan kun kaldes en gang pr. Næste () opkald.

Hvis iteratoren ikke understøtter fjernbetjening, kaster den det UnSupportedOperationException . Det kaster IllegalStateException hvis den næste metode endnu ikke kaldes.

# 4) forEachRemaining ()

Prototype: ugyldigt forEachRemaining (forbrugerER > handling)
Parametre: handling => handling, der skal udføres
Returtype: ugyldig

Beskrivelse: Udfører den angivne handling på hvert af de resterende elementer i samlingen, indtil alle elementerne er opbrugt, eller handlingen kaster en undtagelse. Undtagelser, der kastes ved handling, udbredes til den, der ringer op.

Hvis handlingen er nul, hæver den nullPointerException . Denne funktion er en ny tilføjelse til Iterator-grænsefladen i Java 8.

Java Iterator Eksempel

Lad os implementere et Java-program for at demonstrere brugen af ​​Iterator-grænsefladen. Følgende program opretter en ArrayList af blomster. Derefter får den en iterator ved hjælp af iterator () -metoden i ArrayList. Derefter krydses listen for at vise hvert element.

import java.util.*; public class Main { public static void main(String() args) { List flowers = new ArrayList(); flowers.add('Rose'); flowers.add('Jasmine'); flowers.add('sunflower'); // Get Iterator IteratorflowersIterator = flowers.iterator(); System.out.println('Contents of ArrayList:'); // Traverse elements using iterator while(flowersIterator.hasNext()){ System.out.print(flowersIterator.next() + ' '); } } }

Produktion:

Iteratoreksempel

Begrænsninger af Iterator Interface

  • Handlingen med at erstatte et element eller tilføje et nyt element kan ikke udføres med denne Iterator.
  • Iterationen fortsætter kun i en retning, dvs. fremad.
  • Understøtter kun sekventiel iteration.
  • Når store datamængder skal gentages, påvirkes Iteratorens ydeevne.

Iterator VsIterabel

Selvom grænsefladerne Iterable og Iterator lyder ens, er de helt forskellige. En klasse, der implementerer Iterable-grænsefladen, får muligheden for at gentage over klasseobjekterne, der bruger iterator-grænsefladen.

Nedenfor er nogle af de største forskelle mellem disse to grænseflader, som du skal være opmærksom på:

Iterabel grænseflade Iterator-interface
Repræsenterer en samling, der kan krydses ved hjælp af foreach-loop.Tillader at gentage en anden samling.
Klassen, der implementerer den iterable grænseflade, skal tilsidesætte metoden iterator ().hasNext () og næste () metoder til Iterator-interface skal tilsidesættes af klasse, der implementerer det.
Gemmer ikke den aktuelle tilstand.Gemmer den aktuelle tilstand af iteration.
En forekomst af iteratorgrænsefladen skal produceres, hver gang iterator () -metoden kaldes.Ingen sådan kontrakt for iterator-interface.
Bevæger sig kun i fremadgående retning.Bevæger sig i fremadgående retning og undergrænseflader som listIterator understøtter tovejskørsel.
Tilbyder ingen metode til at ændre elementerne under iteration.Giver den fjernelsesmetode, der kan fjerne elementet, når iteration er i gang.

ListIterator-interface i Java

Grænsefladen ListIterator er en underinterface af iteratorgrænsefladen. Det fungerer på samlinger af listetyper som Linkedlists, array lists osv. Denne interface overvinder således manglerne i Iterator-interface.

De vigtigste egenskaber ved ListIterator-grænsefladen inkluderer:

  • ListIterator interface udvider Iterator interface.
  • ListIterator-interface understøtter CRUD-operationer, dvs Opret, læs, opdater og slet.
  • Understøtter iteration i både fremad og tilbage retning.
  • Da denne grænseflade er tovejs, placeres markøren altid mellem det forrige og det næste element.
  • Denne grænseflade fungerer hovedsageligt til listeimplementeringer som ArrayList, LinkedList osv.
  • Fås siden Java 1.2

Grænsefladen ListIterator er repræsenteret som vist nedenfor:

Interfaceliste Interterrepræsentation

Som allerede nævnt udvider ListIterator-grænsefladen Iterator-grænsefladen. Bortset fra at understøtte alle metoderne til iterator-interface, som vist ovenfor, har ListIterator-interface også sine egne metoder, der hjælper det med at udføre CRUD-operationer såvel som tovejs iteration.

Lad os diskutere ListIterator-metoderne detaljeret.

ListIterator-metoder

Bemærk, at Iterator-interface-metoderne, next (), hasNext () og remove () fungerer nøjagtigt på samme måde som ListIterator-interface. Derfor springer vi disse metoder over i dette afsnit. Ud over de ovennævnte metoder har ListIterator følgende metoder-

Tidligere()

Prototype: E forrige ()
Parametre: NIL
Returtype:
E- forrige element i listen.
- 1 - hvis iteratoren er i begyndelsen af ​​listen.

Beskrivelse: Denne funktion returnerer det forrige element på listen. Når det forrige element er returneret, flyttes markøren bagud til det næste element.

hasPrevious ()

Prototype: boolean hasPrevious ()
Parametre: NIL
Returtype: true => iterator har flere elementer, når listen køres baglæns.

Beskrivelse: Denne funktion kontrollerer, om ListIterator har flere elementer bagud.

previousIndex

Prototype: int previousIndex ()
Parametre: NIL
Returtype:
int - indeks for det forrige element
- 1 - hvis markøren er i starten af ​​listen.

Beskrivelse: Returnerer indekset for det forrige element, der returneres af det forrige () opkald.

næsteIndex

Prototype: int nextIndex ()
Parametre: NIL
Returtype:
int - næste indeks
- 1 - hvis iteratoren er i slutningen af ​​listen.

Beskrivelse: Returnerer det næste indeks for elementet på listen. Dette element returneres ved et kald til næste () metode.

sæt()

Prototype: ugyldigt sæt (E og)
Parametre: e - element, der skal udskiftes
Returtype: NIL

Beskrivelse: Bruges til at erstatte det sidste element med det givne element e.

tilføje()

Prototype: ugyldig tilføjelse (E e)
Parametre: e - element, der skal tilføjes
Returtype: NIL

Beskrivelse: Føjer nye elementer til listen på en position før det næste () element.

Listeeksteratoreksempel

Nu ved vi, hvad en ListIterator er, og hvad er de forskellige metoder, der understøttes af den. Lad os gå videre og implementere et Java-program for at demonstrere ListIterator.

I dette program har vi brugt ArrayList. Derefter bruger vi ListIterator-metoderne til at krydse listen både fremad og tilbage og vise output.

import java.util.*; class Main { public static void main(String args()) { Listnum_list = new ArrayList(); // Add Elements to ArrayList num_list.add(1); num_list.add(3); num_list.add(5); num_list.add(7); num_list.add(9); // Creatinge a ListIterator ListIteratorlist_it = num_list.listIterator(); System.out.println('Output using forward iteration:'); while (list_it.hasNext()) System.out.print(list_it.next()+' ') ; System.out.print(' Output using backward iteration: ') ; while (list_it.hasPrevious()) System.out.print(list_it.previous()+' '); } }

Produktion:

ListIterator - Output

Indtil videre har vi diskuteret grænsefladerne, iterator og Listiterator, næste vil vi se de forskellige eksempler på brug af disse grænseflader til at krydse forskellige samlinger. Men lad os først se på gennemkørsel af enkle arrays og derefter gå videre til andre samlinger.

Array Iterator

I Java er der to måder at gentage over matrixelementer. Lad os beskrive måderne ved hjælp af kodeeksempler.

# 1) til løkke

Dette er den enkleste måde at gentage sig over en matrix. Vi bruger en enkel til loop, der øger indekset med hver iteration og viser dets indhold.

import java.util.*; public class Main { public static void main(String() args) { int myArray() = {2,4,6,8,10,12,14}; int num; System.out.println('Array contents using for loop:'); for (int i = 0; i

Produktion:

Array Iterator for loop

Ovenstående program viser indholdet af arrayet ved hjælp af for loop.

# 2) for Hver løkke

Dette er den anden måde at gentage over arrays. Her bruger vi en specialiseret til loop eller 'forEach' loop. Her løber vi gennem arrayet for hvert element og viser derefter indholdet.

import java.util.*; public class Main { public static void main(String() args) { int myArray() = {2,4,6,8,10,12,14}; int num; System.out.println('Array contents using for each loop:'); for (int i :myArray) { // accessing each element of array num = i; System.out.print(num + ' '); } } }

Produktion:

Array iterator - output

ForEach er mere optimeret sammenlignet med for loop. Det er kortere at skrive og er også hurtigere.

ArrayList Iterator

Hvis du vil krydse en ArrayList-samling, kan du gøre det ved hjælp af Iterator-grænsefladen. Da iterator er en grænseflade, kan du ikke instantiere den direkte. I stedet kan du bruge ArrayList-samlingens iterator () -metode til at få iteratoren og derefter krydse listen.

Iterator iterator ();

Eksempel til demonstration af ArrayList Iterator.

import java.util.*; public class Main { public static void main(String() args) { ArrayListmyList = new ArrayList(); myList.add('Red'); myList.add('Green'); myList.add('Blue'); myList.add('Brown'); myList.add('Pink'); myList.add('Purple'); Iteratorlist_it = myList.iterator(); System.out.println('Elements in the arrayList:'); while(list_it.hasNext()) System.out.print(list_it.next() + ' '); } }

Produktion:

ArrayList Iterator

LinkedList Iterator

Lad os nu se funktionaliteten af ​​en iterator i tilfælde af LinkedList-samling.

LinkedList-samling understøtter listIterator () -metoden, der returnerer listIterator til at krydse gennem den linkede liste.

Det generelle format for denne funktion er

ListIterator list_iter = LinkedList.listIterator (int-indeks);

Her er indekset et heltal, der angiver placeringen i den sammenkædede liste-samling, hvorfra gennemkørslen skal starte.

Lad os forstå listen iterator i den linkede liste med et eksempelprogram. Vi har ændret det samme array iterator-program og ændret det til at indeholde en listiterator med LinkedList.

import java.util.*; public class Main { public static void main(String() args) { LinkedListmyList = new LinkedList(); myList.add('Red'); myList.add('Green'); myList.add('Blue'); myList.add('Brown'); myList.add('Pink'); myList.add('Purple'); ListIteratorlist_it = myList.listIterator(0); System.out.println('Elements in the LinkedList:'); while(list_it.hasNext()) System.out.print(list_it.next() + ' '); } }

Produktion:

interviewspørgsmål til .net-udviklere

LinkedList iterator - output

Java Map / Hashmap Iterator

Kort eller dets variationer som hashmap, treemap osv. Er ikke samlinger. Derfor kan du ikke bruge iterator-metoden direkte på den. I stedet skal du gentage nøgleindgangsværdierne for at læse nøgle / værdiparene.

Selvom du kan bruge forskellige metoder som forEach, for loop osv. Til at gentage kortværdier, er det den bedste og effektive metode at bruge en iterator til at gentage gennem nøgleværdierne. Derudover kan du også fjerne poster fra kortet under iteration ved hjælp af metoden remove.

Eksempel på brug af Iterator med HashMap.

import java.util.*; class Main { public static void main(String() arg) { MapmyMap = new HashMap(); // enter name/url pair myMap.put(1, 'India'); myMap.put(2, 'Nepal'); myMap.put(3, 'Maldives'); myMap.put(4, 'SriLanka'); System.out.println(' SAARC Member Countries '); System.out.println(' KEY' + ' ' + ' COUNTRY' ); // using iterators Iteratormap_itr = myMap.entrySet().iterator(); while(map_itr.hasNext()) { Map.Entrymap_entry = map_itr.next(); System.out.println(' ' + map_entry.getKey() + ' ' + map_entry.getValue()); } } }

Produktion:

Javamap hashmap iterator

I ovenstående program har vi defineret et kort med heltalstaster og strengtypeværdier. Derefter definerer vi en iterator over kortet. Indtast og vis nøgle / værdiparene.

Java Set Iterator

Iterator () -metoden i Java.util.set bruges til at få iteratoren, der returnerer elementerne i sættet i tilfældig rækkefølge.

Iterator set_iterator = Set.iterator();

'Set_iterator' gentager sig over de forskellige elementer i sættet og returnerer deres værdier.

På en lignende måde indeholder hashsættet også en iteratorfunktion, der returnerer en iterator som en sæt iterator.

Iterator hashset_iterator = Hash_Set.iterator();

Nedenfor er programmeringseksemplet til demonstration af sæt iteratoren.

import java.util.*; public class Main { public static void main(String args()) { HashSetsports_set = new HashSet(); sports_set.add('Hocky'); sports_set.add('Kabaddi'); sports_set.add('Football'); sports_set.add('Badminton'); sports_set.add('Cricket'); System.out.println('Sports HashSet: ' + sports_set); // Creating an iterator Iterator hashset_iter = sports_set.iterator(); // Displaying the values after iterating through the set System.out.println(' SportsSet iterator values:'); while (hashset_iter.hasNext()) { System.out.println(hashset_iter.next()); } } }

Produktion:

Java-sæt iterator

Denne implementering bruger HashSet iterator og viser individuelle værdier ved at gentage dem over HashSet-elementerne.

Iterator vs ListIterator

Lad os tabulere de vigtigste forskelle mellem Iterator- og ListIterator-grænseflader.

Iterator ListIterator
Kan krydse alle samlinger inklusive sæt, kort osv.Det kan bruges til kun at krydse samling af listetyper som ArrayList, LinkedList.
Samler kun samlingen i retning fremad.Kan gentage sig over samlingen både fremad og bagud.
Kan ikke få indekser.Kan få indekser.
Ingen måde at tilføje nye elementer til samlingen.Du kan tilføje nye elementer til samlingen.
Iterator kan ikke ændre elementerne under iteration.ListIterator kan ændre elementerne i samlingen ved hjælp af metoden set ().

Ofte stillede spørgsmål

Q # 1) Hvad er gentagelsen i Java?

Svar: En iteration er en proces, hvor en kodeblok gentagne gange udføres, indtil en given tilstand holder eller ikke eksisterer. Ved hjælp af iteration kan du krydse gennem en sekvens af elementer eller behandle dataene.

Spørgsmål nr. 2) Hvor mange typer Iteratorer er der i Java?

Svar: Iteratorer bruges til at krydse gennem samlingerne i Java.

Der er tre typer iteratorer i Java:

  • Tællere
  • Iteratorer
  • ListIterators

Spørgsmål nr. 3) Hvordan bruger jeg en Iterator i Java?

Svar: For at bruge iteratoren til at krydse gennem samlingen skal du først hente iteratoren ved hjælp af iterator () -metoden i den angivne samling.

Derefter kan du bruge itNatorens hasNext () og næste () metoder til at få elementet.

Q # 4) Hvorfor bruges Iterator i stedet for til loop?

Svar: Både iteratoren såvel som for loop bruges til gentagne gange at udføre en bestemt kodeblok. Men den største forskel er, at i for loop kan du ikke ændre eller ændre indholdet i samlingen. Selvom du forsøger at ændre det, kaster det concurrentModificationException. Ved hjælp af iterator kan du fjerne et element fra samlingen.

Spørgsmål nr. 5) Hvorfor har vi brug for Iterator i Java?

Svar: Iterator hjælper dig med at hente elementerne i samlingen eller en container uden at programmøren behøver at kende samlingens interne struktur eller funktion. De er mere elegante, bruger mindre hukommelse, og programmøren spares også for at skrive lang kode.

For det andet kan elementerne gemmes i samlingen på enhver måde, men ved hjælp af en iterator kan programmøren hente dem ligesom en liste eller en hvilken som helst anden sekvens.

Konklusion

Vi har diskuteret iteratorerne i Java, der bruges med samlinger i denne vejledning. Denne viden om iteratorer hjælper læserne med at forstå de samlinger, som vi skal lære i vores efterfølgende tutorials.

Anbefalet læsning

^