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.

math.pow java

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 .

Collezionenomi = nuovo ArrayList<>();
Iteratoreitr = 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:

Iteratorecittà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.