Een gids voor Iterator in Java

1. Inleiding

Een Iterator is een van de vele manieren waarop we een verzameling kunnen doorkruisen, en zoals elke optie heeft het zijn voor- en nadelen.

Het werd voor het eerst geïntroduceerd in Java 1.2 als vervanging van Opsommingen en:

  • introduceerde verbeterde methodenamen
  • maakte het mogelijk om elementen te verwijderen uit een verzameling die we herhalen
  • garandeert geen herhalingsvolgorde

In deze tutorial gaan we de simpele Iterator interface om te leren hoe we de verschillende methoden kunnen gebruiken.

We zullen ook de meer robuuste ListIterator extensie die een aantal interessante functionaliteit toevoegt.

2. Het Iterator Koppel

Om te beginnen hebben we een Iterator van een Verzameling; dit wordt gedaan door de iterator () methode.

Voor de eenvoud zullen we verkrijgen Iterator instantie uit een lijst:

Lijstitems = ... Iterator iter = items.iterator ();

De Iterator interface heeft drie kernmethoden:

2.1. hasNext ()

De hasNext () methode kan worden gebruikt om te controleren of er ten minste één element overblijft om te herhalen.

Het is ontworpen om te worden gebruikt als conditie in terwijl lussen:

while (iter.hasNext ()) {// ...}

2.2. De volgende()

De De volgende() methode kan worden gebruikt om over het volgende element te stappen en het te verkrijgen:

String next = iter.next ();

Het is een goede gewoonte om hasNext () voordat u probeert te bellen De volgende().

Iteratoren voor Collecties garandeer geen iteratie in een bepaalde volgorde, tenzij een bepaalde implementatie dit biedt.

2.3. verwijderen()

Eindelijk, als we dat willen verwijder het huidige element uit de verzameling, we kunnen de verwijderen:

iter.remove ();

Dit is een veilige manier om elementen te verwijderen terwijl je door een verzameling loopt zonder het risico van een ConcurrentModificationException.

2.4. Vol Iterator Voorbeeld

Nu kunnen we ze allemaal combineren en kijken hoe we de drie methoden samen gebruiken voor het filteren van collecties:

while (iter.hasNext ()) {String next = iter.next (); System.out.println (volgende); if ("TWEE" .equals (volgende)) {iter.remove (); }}

Dit is hoe we gewoonlijk een Iterator, we controleren van tevoren of er een ander element is, we halen het op en voeren er dan wat actie op uit.

2.5. Itereren met Lambda-uitdrukkingen

Zoals we in de vorige voorbeelden hebben gezien, is het erg uitgebreid om een Iterator als we gewoon alle elementen willen doornemen en er iets mee willen doen.

Sinds Java 8 hebben we de voor elk overgebleven methode die het gebruik van lambda's mogelijk maakt om de resterende elementen te verwerken:

iter.forEachRemaining (System.out :: println);

3. Het ListIterator Koppel

ListIterator is een extensie die nieuwe functionaliteit toevoegt voor het herhalen van lijsten:

ListIterator listIterator = items.listIterator (items.size ());

Merk op hoe we een startpositie kunnen bieden die in dit geval het einde is van de Lijst.

3.1. hasPrevious () en vorige ()

ListIterator kan worden gebruikt voor achterwaartse verplaatsing, dus het biedt equivalenten van hasNext () en De volgende():

while (listIterator.hasPrevious ()) {String previous = listIterator.previous (); }

3.2. volgendeIndex () en vorigeIndex ()

Bovendien kunnen we indices doorlopen en niet feitelijke elementen:

String nextWithIndex = items.get (listIterator.nextIndex ()); String previousWithIndex = items.get (listIterator.previousIndex ());

Dit kan erg handig zijn als we de indexen moeten weten van de objecten die we momenteel aanpassen, of als we een register willen bijhouden van verwijderde elementen.

3.3. toevoegen()

De toevoegen methode, die, zoals de naam suggereert, ons in staat stelt om een ​​element toe te voegen vóór het item dat zou worden geretourneerd door De volgende() en na degene die langskwam vorige ():

listIterator.add ("VIER");

3.4. set ()

De laatste methode die het vermelden waard is, is set (), waarmee we het element kunnen vervangen dat werd geretourneerd in de aanroep naar De volgende() of vorige ():

String next = listIterator.next (); if ("ONE" .equals (next)) {listIterator.set ("SWAPPED"); }

Het is belangrijk om dat op te merken dit kan alleen worden uitgevoerd als er geen eerdere oproepen zijn naar toevoegen() of verwijderen() zijn gemaakt.

3.5. Vol ListIterator Voorbeeld

We kunnen ze nu allemaal combineren om een ​​compleet voorbeeld te maken:

ListIterator listIterator = items.listIterator (); while (listIterator.hasNext ()) {String nextWithIndex = items.get (listIterator.nextIndex ()); String next = listIterator.next (); if ("VERVANG ME" .equals (volgende)) {listIterator.set ("REPLACED"); }} listIterator.add ("NIEUW"); while (listIterator.hasPrevious ()) {String previousWithIndex = items.get (listIterator.previousIndex ()); String previous = listIterator.previous (); System.out.println (vorige); }

In dit voorbeeld beginnen we met het ophalen van de ListIterator van de Lijst, dan kunnen we het volgende element verkrijgen via index -wat het interne huidige element van de iterator niet verhoogt - of door te bellen De volgende.

Dan kunnen we een specifiek item vervangen door set en plaats een nieuwe met toevoegen.

Nadat we het einde van de iteratie hebben bereikt, kunnen we achteruit gaan om aanvullende elementen te wijzigen of ze gewoon van onder naar boven afdrukken.

4. Conclusie

De Iterator interface stelt ons in staat om een ​​verzameling aan te passen terwijl we deze doorlopen, wat moeilijker is met een simpele for / while-instructie. Dit geeft ons op zijn beurt een goed patroon dat we in veel methoden kunnen gebruiken, waarvoor alleen de verwerking van collecties nodig is met behoud van een goede cohesie en een lage koppeling.

Eindelijk, zoals altijd is de volledige broncode beschikbaar op GitHub.