streamalism.org

1. Introduksjon

An Iterator er en av mange måter vi kan krysse en samling på, og som alle muligheter har den sine fordeler og ulemper.

Den ble først introdusert i Java 1.2 som erstatning for Oppregninger og:

• introduserte forbedrede metodenavn
• gjort det mulig å fjerne elementer fra en samling vi itererer over
• garanterer ikke iterasjonsrekkefølge

I denne opplæringen skal vi gjennomgå det enkle Iterator grensesnitt for å lære hvordan vi kan bruke de forskjellige metodene.

Vi vil også sjekke det mer robuste ListIterator utvidelse som gir litt interessant funksjonalitet.

2. Den Iterator Grensesnitt

For å starte, må vi skaffe en Iterator fra en Samling; dette gjøres ved å ringe iterator () metode.

For enkelhets skyld får vi Iterator forekomst fra en liste:

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

De Iterator grensesnittet har tre kjernemetoder:

2.1. hasNext ()

De hasNext () metoden kan brukes for å sjekke om det er minst ett element igjen å itere.

Den er designet for å brukes som en tilstand i samtidig som sløyfer:

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

2.2. neste ()

De neste () metoden kan brukes til å gå over det neste elementet og få det:

Streng neste = iter.next ();

Det er god praksis å bruke hasNext () før du prøver å ringe neste ().

Iteratorer til Samlinger garanterer ikke iterasjon i en bestemt rekkefølge med mindre spesiell implementering gir det.

2.3. fjerne()

Til slutt, hvis vi vil fjern det nåværende elementet fra samlingen, vi kan bruke fjerne:

iter.remove ();

Dette er en trygg måte å fjerne elementer mens det gjentas over en samling uten risiko for a ConcurrentModificationException.

2.4. Full Iterator Eksempel

Nå kan vi kombinere dem alle og se på hvordan vi bruker de tre metodene sammen for innsamlingsfiltrering:

while (iter.hasNext ()) {Streng neste = iter.next (); System.out.println (neste); if ("TWO" .equals (next)) {iter.remove (); }}

Slik bruker vi ofte en Iterator, vi sjekker på forhånd om det er et annet element, vi henter det og deretter utfører vi noen handlinger på det.

2.5. Iterere med Lambda-uttrykk

Som vi så i de foregående eksemplene, er det veldig ordentlig å bruke en Iterator når vi bare vil gå gjennom alle elementene og gjøre noe med dem.

Siden Java 8 har vi forEachRemaining metode som tillater bruk av lambdas til å behandle gjenværende elementer:

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

3. Den ListIterator Grensesnitt

ListIterator er en utvidelse som legger til ny funksjonalitet for iterering over lister:

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

Legg merke til hvordan vi kan gi en utgangsposisjon som i dette tilfellet er slutten på Liste.

3.1. hasPrevious () og tidligere()

ListIterator kan brukes til bakoverkjøring, slik at den gir ekvivalenter av hasNext () og neste ():

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

3.2. nextIndex () og previousIndex ()

I tillegg kan vi krysse over indekser og ikke faktiske elementer:

Streng nextWithIndex = items.get (listIterator.nextIndex ()); Streng tidligereWithIndex = items.get (listIterator.previousIndex ());

Dette kan vise seg å være veldig nyttig hvis vi trenger å kjenne indeksene til objektene vi endrer for øyeblikket, eller hvis vi vil føre oversikt over fjernede elementer.

3.3. legge til()

De legge til metode, som, som navnet antyder, lar oss legge til et element før varen som skulle returneres av neste () og etter at den kom tilbake tidligere():

listIterator.add ("FOUR");

3.4. sett()

Den siste metoden det er verdt å nevne er sett(), som lar oss erstatte elementet som ble returnert i samtalen til neste () eller tidligere():

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

Det er viktig å merke seg det dette kan bare utføres hvis ingen tidligere samtaler til legge til() eller fjerne() Ble laget.

3.5. Full ListIterator Eksempel

Vi kan nå kombinere dem alle for å lage et komplett eksempel:

ListIterator listIterator = items.listIterator (); while (listIterator.hasNext ()) {String nextWithIndex = items.get (listIterator.nextIndex ()); Streng neste = listIterator.next (); if ("REPLACE ME" .equals (next)) {listIterator.set ("REPLACED"); }} listIterator.add ("NEW"); while (listIterator.hasPrevious ()) {String previousWithIndex = items.get (listIterator.previousIndex ()); String forrige = listIterator.previous (); System.out.println (forrige); }

I dette eksemplet starter vi med å få ListIterator fra Liste, så kan vi oppnå neste element enten ved indeks -som ikke øker iteratorens interne strømelement - eller ved å ringe neste.

Da kan vi erstatte en bestemt vare med sett og sett inn en ny med legge til.

Etter å ha nådd slutten av iterasjonen, kan vi gå bakover for å endre flere elementer eller bare skrive dem ut fra bunnen til toppen.

4. Konklusjon

De Iterator grensesnittet lar oss endre en samling mens vi krysser den, noe som er vanskeligere med en enkel for / mens uttalelse. Dette gir oss igjen et godt mønster vi kan bruke i mange metoder som bare krever behandling av samlinger samtidig som vi opprettholder god kohesjon og lav kobling.

Til slutt, som alltid, er hele kildekoden tilgjengelig på GitHub.