En iterator i Java er en av de mest brukte markører i Java Collections Framework . Den brukes til å krysse eller iterere gjennom elementer i en samling én etter én.

• Den brukes kun til å krysse elementer i foroverretningen.
• Fjerner elementer trygt under traversering ved hjelp av remove().
• Iterator er en universell markør som gjelder for alle samlingstyper - Listesett og Kø.

Erklæring fra Iterator

offentlig grensesnitt Iterator

Her representerer E typen elementer som skal itereres over.

Objektoppretting av Iterator

Et Iterator-objekt opprettes ved å kalle iterator()-metoden på et samlingsobjekt. Her skal vi bruke en Iterator for å krysse og skrive ut hvert element i en ArrayList .

Samling navn = ny ArrayList <>();
Iterator itr = navn.iterator();

   import     java.util.ArrayList  ;   import     java.util.Iterator  ;   public     class   Geeks     {      public     static     void     main  (  String  []     args  )     {          // Create an ArrayList and add some elements      ArrayList   <  String  >     al     =     new     ArrayList   <>  ();      al  .  add  (  'A'  );      al  .  add  (  'B'  );      al  .  add  (  'C'  );      // Obtain an iterator for the ArrayList      Iterator   <  String  >     it     =     al  .  iterator  ();      // Iterate through the elements and print each one      while     (  it  .  hasNext  ())     {          // Get the next element      String     n     =     it  .  next  ();         System  .  out  .  println  (  n  );         }      }   }   

A B C  

Hierarki av Iterator

Iterator er en del av java.util-pakken og implementeres av alle samlingsklasser gjennom deres undergrensesnitt.

Metoder for iteratorgrensesnitt

Iteratorgrensesnittet definerer tre metoder som er oppført nedenfor:

• hasNext(): Returnerer sann hvis iterasjonen har flere elementer.
• neste(): Returnerer neste element i iterasjonen. Det kaster NoSuchElementException hvis ikke flere element er tilstede.
• fjerne(): Fjerner det siste elementet returnert av next(). Denne metoden kan bare kalles én gang per kall til neste().

Note : remove()-metoden kan gi to unntak, nemlig som følger:

Internt arbeid

I denne delen vil vi prøve å forstå hvordan Java Iterator og dens metoder fungerer internt. La oss ta følgende LinkedList-objekt for å forstå denne funksjonaliteten.

Trinn 1: La oss nå lage et Iterator-objekt på List-objektet som vist nedenfor:

Iterator byerIterator = byer.iterator();

'CitiesIteartor'-iteratoren vil se slik ut:

Her peker Iterators markør foran det første elementet i listen.

Trinn 2: Nå skal vi kjøre følgende kodebit.

cityIterator.hasNext();
byerIterator.neste();

Når vi kjører kodebiten ovenfor, peker Iterators markør til det første elementet i listen som vist i diagrammet ovenfor.

Trinn 3: Nå skal vi kjøre følgende kodebit.

cityIterator.hasNext();
byerIterator.neste();

Når vi kjører kodebiten ovenfor, peker Iterators markør til det andre elementet i listen som vist i diagrammet ovenfor.

Trinn 4: Gjør denne prosessen for å nå Iteratorens markør til sluttelementet på listen.

Trinn 5: Etter å ha lest det siste elementet hvis vi kjører kodebiten nedenfor, returnerer det en falsk verdi.

cityIterator.hasNext();

Som Iterators markør peker på etter det siste elementet i listen hasNext() metoden returnerer en falsk verdi.

Note: Java Iterator støtter bare forovergående iterasjon, så det er kjent som en ensrettet markør. Derimot er ListIterator toveis som tillater traversering i begge retninger.

Eksempel: Her vil vi bruke en iterator for å krysse og fjerne odde elementer fra en ArrayList.

   import     java.util.ArrayList  ;   import     java.util.Iterator  ;   public     class   Geeks     {      public     static     void     main  (  String  []     args  )     {          // Creating an ArrayList of Integer type      ArrayList   <  Integer  >     al     =     new     ArrayList   <>  ();      // Adding elements to the ArrayList      for     (  int     i     =     0  ;     i      <     10  ;     i  ++  )     {      al  .  add  (  i  );      }      // Printing the original list      System  .  out  .  println  (  'Original List: '     +     al  );      // Creating an Iterator for the ArrayList      Iterator   <  Integer  >     itr     =     al  .  iterator  ();      // Iterating through the list and removing odd elements      while     (  itr  .  hasNext  ())     {          // Getting the next element      int     i     =     itr  .  next  ();             System  .  out  .  print  (  i     +     ' '  );         // Removing odd elements      if     (  i     %     2     !=     0  )     {      itr  .  remove  ();      }      }      System  .  out  .  println  ();      // Printing the modified list after removal of odd elements      System  .  out  .  println  (  'Modified List: '     +     al  );      }   }   

Original List: [0 1 2 3 4 5 6 7 8 9] 0 1 2 3 4 5 6 7 8 9 Modified List: [0 2 4 6 8]  

Forklaring: I eksemplet ovenfor lager vi en ArrayList med heltall, og itererer deretter gjennom den ved å bruke en iterator og fjerner alle oddetall. Den skriver ut listen før og etter fjerning av oddeelementer og skriver ut den endrede listen med bare partall.