En iterator i Java er en af ​​de mest brugte markører i Java Collections Framework . Det bruges til at krydse eller iterere gennem elementer i en samling én efter én.

• Den bruges kun til at krydse elementer i fremadgående retning.
• Fjerner elementer sikkert under traversering ved hjælp af remove().
• Iterator er en universel markør, der gælder for alle samlingstyper - Listesæt og Kø.

Deklaration af iterator

offentlig interface Iterator

Her repræsenterer E den type elementer, der skal itereres over.

Objektoprettelse af Iterator

Et Iterator-objekt oprettes ved at kalde iterator()-metoden på et samlingsobjekt. Her vil vi bruge en Iterator til at krydse og udskrive hvert element i en ArrayList .

Samling navne = ny ArrayList <>();
Iterator itr = navne.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  

Iteratorhierarki

Iterator er en del af java.util-pakken og implementeres af alle samlingsklasser gennem deres undergrænseflader.

Metoder til iteratorgrænseflade

Iteratorgrænsefladen definerer tre metoder som angivet nedenfor:

• hasNext(): Returnerer sand, hvis iterationen har flere elementer.
• næste(): Returnerer det næste element i iterationen. Det kaster NoSuchElementException hvis der ikke er mere element til stede.
• fjerne(): Fjerner det sidste element returneret af next(). Denne metode kan kun kaldes én gang pr. kald til next().

Note : remove() metoden kan give to undtagelser, nemlig som følger:

Internt arbejde

I dette afsnit vil vi forsøge at forstå, hvordan Java Iterator og dets metoder fungerer internt. Lad os tage følgende LinkedList-objekt for at forstå denne funktionalitet.

Trin 1: Lad os nu oprette et Iterator-objekt på List-objektet som vist nedenfor:

Iterator byerIterator = byer.iterator();

Iteratoren 'citiesIteartor' vil se ud som nedenfor:

Her peger Iterators markør før det første element i listen.

Trin 2: Nu kører vi følgende kodestykke.

byerIterator.hasNext();
byerIterator.next();

Når vi kører ovenstående kodestykke, peger Iterators markør på det første element på listen som vist i ovenstående diagram.

Trin 3: Nu kører vi følgende kodestykke.

byerIterator.hasNext();
byerIterator.next();

Når vi kører ovenstående kodestykke, peger Iterators markør på det andet element på listen som vist i ovenstående diagram.

Trin 4: Udfør denne proces for at nå Iteratorens markør til slutelementet på listen.

Trin 5: Efter at have læst det sidste element, hvis vi kører nedenstående kodestykke, returnerer det en falsk værdi.

byerIterator.hasNext();

Som Iterators markør peger på efter det sidste element på listen hasNext() metode returnerer en falsk værdi.

Note: Java Iterator understøtter kun fremadgående iteration, så den er kendt som en ensrettet markør. I modsætning hertil er ListIterator tovejs, hvilket tillader traversering i begge retninger.

Eksempel: Her vil vi bruge en Iterator til at krydse og fjerne ulige 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 ovenstående eksempel opretter vi en ArrayList af heltal, og gentager den derefter ved hjælp af en iterator og fjerner alle ulige tal. Den udskriver listen før og efter fjernelse af de ulige elementer og udskriver den ændrede liste med kun lige tal.