Útmutató az Iterator Java-hoz

1. Bemutatkozás

An Iterátor a sokféle módszer egyike, amelyeken keresztül haladhatunk egy gyűjteményen, és mint minden lehetőségnek, megvannak az előnyei és hátrányai is.

Először a Java 1.2-ben vezették be a Felsorolás és:

  • továbbfejlesztett módszerneveket vezetett be
  • lehetővé tette az elemek eltávolítását egy gyűjteményből, amelyet iterálunk
  • nem garantálja az iterációs sorrendet

Ebben az oktatóanyagban áttekintjük az egyszerűt Iterátor felületen, hogy megtanulják, hogyan használhatjuk különböző módszereit.

Megvizsgáljuk a robusztusabbakat is ListIterator kiterjesztés, amely érdekes funkciókat kínál.

2. A Iterátor Felület

A kezdéshez meg kell szereznünk egy Iterátor a-tól Gyűjtemény; ezt a iterátor () módszer.

Az egyszerűség kedvéért megkapjuk Iterátor példány egy listából:

Lista tételek = ... Iterátor iter = tételek.iterátor ();

A Iterátor Az interfész három alapvető módszerrel rendelkezik:

2.1. hasNext ()

A hasNext () metódus használható annak ellenőrzésére, hogy van-e legalább egy elem az ismétléshez.

Úgy tervezték, hogy feltételként használják míg hurkok:

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

2.2. következő()

A következő() metódus használható a következő elem átlépésére és megszerzésére:

Karakterlánc következő = iter.next ();

Jó gyakorlat használni hasNext () mielőtt megkísérelné felhívni következő().

Iterátorok mert Gyűjtemények csak akkor garantálja az iterációt, ha egy adott megvalósítás biztosítja.

2.3. eltávolítás ()

Végül, ha akarjuk távolítsa el az aktuális elemet a gyűjteményből, használhatjuk a eltávolítás:

iter.remove ();

Ez egy biztonságos módja az elemek eltávolításának, miközben a gyűjteményen keresztül ismétlik az a veszélyt ConcurrentModificationException.

2.4. Teljes Iterátor Példa

Most egyesíthetjük mindet, és megnézhetjük, hogyan használjuk együtt a három módszert a gyűjteményszűréshez:

while (iter.hasNext ()) {String next = iter.next (); System.out.println (következő); if ("KÉT" .egyenlő (következő)) {iter.remove (); }}

Így szoktuk használni az Iterátor, idő előtt ellenőrizzük, van-e másik elem, visszakeresjük, majd végrehajtunk rajta valamilyen műveletet.

2.5. Lambda kifejezésekkel iterálva

Ahogy az előző példákban láthattuk, nagyon bő egy an használata Iterátor amikor csak át akarunk menni az összes elemen és tenni velük valamit.

Java 8 óta megvan a forEachRemaining módszer, amely lehetővé teszi lambdas használatát a többi elem feldolgozásához:

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

3. Az ListIterator Felület

ListIterator egy olyan bővítmény, amely új funkciókat ad hozzá a listákon történő ismétléshez:

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

Figyelje meg, hogyan adhatunk kiindulási helyzetet, amely ebben az esetben a Lista.

3.1. hasPrevious () és előző()

ListIterator felhasználható a visszafelé történő áthaladáshoz, így ennek megfelelőit biztosítja hasNext () és következő():

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

3.2. nextIndex () és előzőIndex ()

Ezenkívül áttekinthetünk indexeket és nem tényleges elemeket:

String nextWithIndex = items.get (listIterator.nextIndex ()); String előzőWithIndex = items.get (listIterator.previousIndex ());

Ez nagyon hasznosnak bizonyulhat abban az esetben, ha ismernünk kell az éppen módosított objektumok indexeit, vagy ha nyilvántartást akarunk vezetni az eltávolított elemekről.

3.3. add ()

A hozzá metódus, amely - amint a neve is sugallja - lehetővé teszi számunkra az elem hozzáadását a visszaküldendő tétel előtt következő() és miután visszatért előző():

listIterator.add ("NÉGY");

3.4. készlet()

Az utolsó említésre méltó módszer az készlet(), amellyel helyettesíthetjük a hívásban visszaadott elemet következő() vagy előző():

Karakterlánc következő = listIterator.next (); if ("ONE" .egyenlő (következő)) {listIterator.set ("SWAPPED"); }

Fontos megjegyezni ez csak akkor hajtható végre, ha nincs előzetes hívás add () vagy eltávolítás () készült.

3.5. Teljes ListIterator Példa

Most mindegyiket kombinálhatjuk, hogy teljes példát állítsunk elő:

ListIterator listIterator = items.listIterator (); while (listIterator.hasNext ()) {String nextWithIndex = items.get (listIterator.nextIndex ()); Karakterlánc következő = listIterator.next (); if ("REPLACE ME" .egyenlő (következő)) {listIterator.set ("REPLACED"); }} listIterator.add ("ÚJ"); while (listIterator.hasPrevious ()) {String előzőWithIndex = items.get (listIterator.previousIndex ()); Karakterlánc előző = listIterator.previous (); System.out.println (előző); }

Ebben a példában azzal kezdjük, hogy megkapjuk a ListIterator tól Lista, akkor akár index alapján is megszerezhetjük a következő elemet -ami nem növeli az iterátor belső áramelemét - vagy hívással következő.

Ezután helyettesíthetünk egy adott elemet a következővel: készlet és helyezzen be egy újat hozzá.

Miután elértük az iteráció végét, visszaléphetünk a további elemek módosításához, vagy egyszerűen kinyomtathatjuk alulról felfelé.

4. Következtetés

A Iterátor Az interfész lehetővé teszi számunkra, hogy egy gyűjtemény módosítását végigjárjuk, ami egy egyszerű for / while utasítással nehezebb. Ez viszont jó mintát ad számunkra, amelyet számos olyan módszerben alkalmazhatunk, amely csak a gyűjtemények feldolgozását igényli, a jó kohézió és az alacsony csatolás fenntartása mellett.

Végül, mint mindig, a teljes forráskód elérhető a GitHub oldalon.