En Iterator i Java är en av de mest använda markörer i Java Collections Framework . Den används för att gå igenom eller iterera genom element i en samling en efter en.

• Den används endast för att korsa element i framåtriktningen.
• Tar bort element säkert under traversering med remove().
• Iterator är en universell markör som gäller för alla samlingstyper — Listuppsättning och Kö.

Deklaration av Iterator

offentligt gränssnitt Iterator

Här representerar E typen av element som ska itereras över.

Objektskapande av Iterator

Ett Iterator-objekt skapas genom att anropa iterator()-metoden på ett samlingsobjekt. Här kommer vi att använda en Iterator för att gå igenom och skriva ut varje element i en ArrayList .

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

Iteratorns hierarki

Iterator är en del av java.util-paketet och implementeras av alla samlingsklasser genom deras undergränssnitt.

Metoder för iteratorgränssnitt

Iteratorgränssnittet definierar tre metoder som listas nedan:

• hasNext(): Returnerar sant om iterationen har fler element.
• nästa(): Returnerar nästa element i iterationen. Det kastar NoSuchElementException om inget mer element är närvarande.
• ta bort(): Tar bort det sista elementet som returneras av next(). Denna metod kan endast anropas en gång per anrop till next().

Notera : remove()-metoden kan ge två undantag, nämligen enligt följande:

Internt arbete

I det här avsnittet ska vi försöka förstå hur Java Iterator och dess metoder fungerar internt. Låt oss ta följande LinkedList-objekt för att förstå denna funktionalitet.

Steg 1: Låt oss nu skapa ett Iterator-objekt på List-objektet som visas nedan:

Iterator städerIterator = städer.iterator();

Iteratorn 'citiesIteartor' kommer att se ut så här:

Här pekar Iterators markör före det första elementet i listan.

Steg 2: Nu kör vi följande kodavsnitt.

städerIterator.hasNext();
städerIterator.next();

När vi kör ovanstående kodavsnitt pekar Iterators markör på det första elementet i listan som visas i diagrammet ovan.

Steg 3: Nu kör vi följande kodavsnitt.

städerIterator.hasNext();
städerIterator.next();

När vi kör ovanstående kodavsnitt pekar Iterators markör på det andra elementet i listan som visas i diagrammet ovan.

Steg 4: Gör denna process för att nå Iteratorns markör till slutet av listan.

Steg 5: Efter att ha läst det sista elementet om vi kör kodavsnittet nedan returnerar det ett falskt värde.

städerIterator.hasNext();

Som Iterators markör pekar på efter det sista elementet i listan hasNext() metod returnerar ett falskt värde.

Notera: Java Iterator stöder endast iteration i framåtriktad riktning så den är känd som en enkelriktad markör. Däremot är ListIterator dubbelriktad och tillåter genomflyttning i båda riktningarna.

Exempel: Här kommer vi att använda en Iterator för att korsa och ta bort udda element från 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]  

Förklaring: I exemplet ovan skapar vi en ArrayList med heltal och itererar sedan genom den med en Iterator och tar bort alla udda tal. Den skriver ut listan före och efter att de udda elementen tagits bort och den ändrade listan skrivs ut med endast jämna nummer.