Java - Come utilizzare Iterator?

Spesso, vorrai scorrere gli elementi in una raccolta. Ad esempio, potresti voler visualizzare ogni elemento. Il modo più semplice per farlo è utilizzare un iteratore, che è un oggetto che implementa l'interfaccia Iterator o ListIterator.

Iterator ti consente di scorrere una raccolta, ottenendo o rimuovendo elementi. ListIterator estende Iterator per consentire l'attraversamento bidirezionale di un elenco e la modifica degli elementi.

Prima di poter accedere a una raccolta tramite un iteratore, è necessario ottenerne uno. Ciascuna delle classi di raccolta fornisce un metodo iterator () che restituisce un iteratore all'inizio della raccolta. Utilizzando questo oggetto iteratore, è possibile accedere a ogni elemento della raccolta, un elemento alla volta.

In generale, per utilizzare un iteratore per scorrere i contenuti di una raccolta, segui questi passaggi:

  • Ottieni un iteratore all'inizio della raccolta chiamando il metodo iterator () della raccolta.

  • Imposta un ciclo che effettui una chiamata a hasNext (). Fai in modo che il ciclo esegua l'iterazione finché hasNext () restituisce true.

  • All'interno del ciclo, ottieni ogni elemento chiamando next ().

Per le raccolte che implementano List, è anche possibile ottenere un iteratore chiamando ListIterator.

I metodi dichiarati da Iterator

Sr.No. Metodo e descrizione
1

boolean hasNext( )

Restituisce vero se sono presenti più elementi. In caso contrario, restituisce false.
2

Object next( )

Restituisce l'elemento successivo. Genera NoSuchElementException se non è presente un elemento successivo.
3

void remove( )

Rimuove l'elemento corrente. Genera IllegalStateException se viene effettuato un tentativo di chiamare remove () che non è preceduto da una chiamata a next ().

I metodi dichiarati da ListIterator

Sr.No. Metodo e descrizione
1

void add(Object obj)

Inserisce obj nell'elenco davanti all'elemento che verrà restituito dalla successiva chiamata a next ().
2

boolean hasNext( )

Restituisce vero se c'è un elemento successivo. In caso contrario, restituisce false.
3

boolean hasPrevious( )

Restituisce vero se è presente un elemento precedente. In caso contrario, restituisce false.
4

Object next( )

Restituisce l'elemento successivo. Se non è presente un elemento successivo, viene generata un'eccezione NoSuchElementException.
5

int nextIndex( )

Restituisce l'indice dell'elemento successivo. Se non è presente un elemento successivo, restituisce la dimensione dell'elenco.
6

Object previous( )

Restituisce l'elemento precedente. Se non è presente un elemento precedente, viene generata un'eccezione NoSuchElementException.
7

int previousIndex( )

Restituisce l'indice dell'elemento precedente. Se non è presente un elemento precedente, restituisce -1.
8

void remove( )

Rimuove l'elemento corrente dall'elenco. Viene lanciata un'eccezione IllegalStateException se remove () viene chiamato prima di next () o previous ().
9

void set(Object obj)

Assegna obj all'elemento corrente. Questo è l'ultimo elemento restituito da una chiamata a next () o previous ().

Esempio

Ecco un esempio che mostra sia Iterator che ListIterator. Utilizza un oggetto ArrayList, ma i principi generali si applicano a qualsiasi tipo di raccolta.

Ovviamente ListIterator è disponibile solo per quelle raccolte che implementano l'interfaccia List.

import java.util.*;
public class IteratorDemo {

   public static void main(String args[]) {
      // Create an array list
      ArrayList al = new ArrayList();
      
      // add elements to the array list
      al.add("C");
      al.add("A");
      al.add("E");
      al.add("B");
      al.add("D");
      al.add("F");

      // Use iterator to display contents of al
      System.out.print("Original contents of al: ");
      Iterator itr = al.iterator();
      
      while(itr.hasNext()) {
         Object element = itr.next();
         System.out.print(element + " ");
      }
      System.out.println();
      
      // Modify objects being iterated
      ListIterator litr = al.listIterator();
      
      while(litr.hasNext()) {
         Object element = litr.next();
         litr.set(element + "+");
      }
      System.out.print("Modified contents of al: ");
      itr = al.iterator();
      
      while(itr.hasNext()) {
         Object element = itr.next();
         System.out.print(element + " ");
      }
      System.out.println();

      // Now, display the list backwards
      System.out.print("Modified list backwards: ");
      
      while(litr.hasPrevious()) {
         Object element = litr.previous();
         System.out.print(element + " ");
      }
      System.out.println();
   }
}

Questo produrrà il seguente risultato:

Produzione

Original contents of al: C A E B D F
Modified contents of al: C+ A+ E+ B+ D+ F+
Modified list backwards: F+ D+ B+ E+ A+ C+