Un Iterator in Java è uno dei più comunemente usati cursori nel Java Collections Framework . Viene utilizzato per attraversare o scorrere gli elementi di una raccolta uno per uno.

• Viene utilizzato per attraversare gli elementi solo nella direzione in avanti.
• Rimuove gli elementi in modo sicuro durante l'attraversamento utilizzando rimuovi().
• Iterator è un cursore universale che si applica a tutti i tipi di raccolta: set di elenchi e coda.

Dichiarazione dell'iteratore

Iteratore dell'interfaccia pubblica

Qui E rappresenta il tipo di elementi su cui eseguire l'iterazione.

Creazione di oggetti di Iterator

Un oggetto Iterator viene creato chiamando il metodo iterator() su un oggetto raccolta. Qui utilizzeremo un Iterator per attraversare e stampare ogni elemento in un file ArrayList .

Collezione nomi = nuovo ArrayList <>();
Iteratore itr = nomi.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  

Gerarchia dell'iteratore

Iterator fa parte di pacchetto java.util ed è implementato da tutte le classi di raccolta attraverso le rispettive sottointerfacce.

Metodi di interfaccia dell'iteratore

L'interfaccia dell'iteratore definisce tre metodi elencati di seguito:

• haNext(): Restituisce vero se l'iterazione ha più elementi.
• Prossimo(): Restituisce l'elemento successivo nell'iterazione. Lancia NoSuchElementException se non è presente più alcun elemento.
• rimuovere(): Rimuove l'ultimo elemento restituito da next(). Questo metodo può essere chiamato solo una volta per chiamata a next().

Nota : il metodo Remove() può generare due eccezioni, ovvero quanto segue:

Lavoro interno

In questa sezione cercheremo di capire come funzionano internamente Java Iterator e i suoi metodi. Prendiamo il seguente oggetto LinkedList per comprendere questa funzionalità.

Passaggio 1: Ora creiamo un oggetto Iterator sull'oggetto List come mostrato di seguito:

Iteratore cittàIterator = città.iterator();

L'iteratore 'citiesIteartor' apparirà come di seguito:

Qui il cursore dell'iteratore punta prima del primo elemento della lista.

Passaggio 2: Ora eseguiremo il seguente frammento di codice.

cittàIterator.hasNext();
cittàIterator.next();

Quando eseguiamo lo snippet di codice sopra, il cursore di Iterator punta al primo elemento dell'elenco come mostrato nel diagramma sopra.

Passaggio 3: Ora eseguiremo il seguente frammento di codice.

cittàIterator.hasNext();
cittàIterator.next();

Quando eseguiamo lo snippet di codice sopra, il cursore di Iterator punta al secondo elemento nell'elenco come mostrato nel diagramma sopra.

Passaggio 4: Esegui questo processo per raggiungere il cursore dell'iteratore sull'elemento finale dell'elenco.

Passaggio 5: Dopo aver letto l'elemento finale, se eseguiamo lo snippet di codice seguente, verrà restituito un valore falso.

cittàIterator.hasNext();

Poiché il cursore dell'iteratore punta dopo l'elemento finale della lista haNext() il metodo restituisce un valore falso.

Nota: Java Iterator supporta solo l'iterazione della direzione in avanti, quindi è noto come cursore unidirezionale. Al contrario ListIterator è bidirezionale consentendo l'attraversamento in entrambe le direzioni.

Esempio: Qui utilizzeremo un Iterator per attraversare e rimuovere elementi dispari da un 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]  

Spiegazione: Nell'esempio sopra creiamo un ArrayList di numeri interi, quindi lo iteriamo utilizzando un Iterator e rimuoviamo tutti i numeri dispari. Stampa l'elenco prima e dopo aver rimosso gli elementi dispari e stampa l'elenco modificato con solo numeri pari.