Menu

Iteratore Java: impara a utilizzare gli iteratori in Java con esempi

  • Principale
  • Altro
  • Iteratore Java: impara a utilizzare gli iteratori in Java con esempi

java iterator learn use iterators java with examples

Prova Il Nostro Strumento Per Eliminare I Problemi

In questo tutorial, impareremo gli iteratori in Java. Avremo una discussione dettagliata sulle interfacce Iterator e ListIterator in Java:

Abbiamo esplorato tutto su Java Collection Framework e le sue varie interfacce e classi di supporto in uno dei nostri tutorial precedenti.

Quando si dispone di una raccolta, si desidera accedere ai suoi elementi, aggiungere / rimuovere o elaborare gli elementi. Per eseguire tutta questa elaborazione tramite un programma Java, dovresti essere in grado di attraversare la raccolta che stai utilizzando. È qui che entra in gioco l'iteratore.

Java Iterator

Cosa imparerai:

Cos'è un iteratore Java?

In Java, un Iterator è un costrutto utilizzato per attraversare o scorrere la raccolta.

Per utilizzare un iteratore, è necessario ottenere l'oggetto iteratore utilizzando il ' iteratore () ' metodo dell'interfaccia di raccolta. Java Iterator è un'interfaccia del framework di raccolta ed è una parte del pacchetto 'java.util'. Utilizzando Java Iterator è possibile iterare attraverso la raccolta di oggetti.

L'interfaccia Java Iterator sostituisce l'enumeratore utilizzato in precedenza per scorrere alcune semplici raccolte come i vettori.

Le principali differenze tra Java Iterator ed Enumerator sono:

  • Notevole miglioramento nei nomi dei metodi.
  • È possibile rimuovere gli elementi del metodo dalla raccolta che viene attraversata utilizzando un iteratore.

In questo tutorial, discuteremo i dettagli dell'interfaccia Iterator e dell'interfaccia ListIterator che è un'interfaccia bidirezionale.

Tipi di iteratori

  • Enumeratore
  • Iteratore
  • ListIterator

Un enumeratore viene utilizzato raramente ora. Quindi, nella nostra serie di tutorial, ci concentreremo sulle interfacce Iterator e ListIterator.

Interfaccia Iterator in Java

L'interfaccia Iterator in Java è una parte del framework Collections nel pacchetto 'java.util' ed è un cursore che può essere utilizzato per scorrere la raccolta di oggetti.

L'interfaccia di Iterator ha le seguenti caratteristiche principali:

  • L'interfaccia Iterator è disponibile dal framework di raccolta Java 1.2 in poi.
  • Attraversa la raccolta di oggetti uno per uno.
  • Popolarmente noto come 'Universal Java Cursor' in quanto funziona con tutte le raccolte.
  • Questa interfaccia supporta le operazioni di 'lettura' e 'rimozione', ovvero è possibile rimuovere un elemento durante un'iterazione utilizzando l'iteratore.

Di seguito viene fornita la rappresentazione generale dell'interfaccia Iterator:

Rappresentazione dell

Successivamente, diamo un'occhiata ai metodi Iterator sopra elencati.

Metodi iteratori

L'interfaccia Iterator supporta i seguenti metodi:

# 1) Avanti ()

Prototipo: E successivo ()
Parametri: nessun parametro
Tipo di ritorno: E -> elemento
Descrizione: Restituisce l'elemento successivo nella raccolta.

Se l'iterazione (raccolta) non ha più elementi, genera NoSuchElementException .

# 2) hasNext ()

Prototipo: booleano hasNext ()
Parametri: NIL
Tipo di ritorno: true => ci sono elementi nella raccolta.

Falso => ​​non più elementi

Descrizione: La funzione hasNext () controlla se ci sono più elementi nella raccolta a cui si accede utilizzando un iteratore. Se non ci sono più elementi, non si chiama il metodo next (). In altre parole, questa funzione può essere utilizzata per decidere se chiamare il metodo next ().

# 3) rimuovi ()

Prototipo: void remove ()
Parametri: NIL
Tipo di ritorno: NIL

Descrizione: Rimuove l'ultimo elemento restituito dall'iteratore che esegue l'iterazione sulla raccolta sottostante. Il metodo remove () può essere chiamato solo una volta per ogni chiamata next ().

Se l'iteratore non supporta l'operazione di rimozione, allora lancia UnSupportedOperationException . Lancia IllegalStateException se il metodo successivo non è ancora stato chiamato.

# 4) forEachRemaining ()

Prototipo: void forEachRemaining (consumerE > azione)
Parametri: azione => azione da eseguire
Tipo di ritorno: vuoto

Descrizione: Esegue l'azione specificata su ciascuno degli elementi rimanenti della raccolta fino a quando tutti gli elementi non sono esauriti o l'azione genera un'eccezione. Le eccezioni generate dall'azione vengono propagate al chiamante.

Se l'azione è nulla, allora solleva nullPointerException . Questa funzione è una nuova aggiunta all'interfaccia Iterator in Java 8.

Esempio di iteratore Java

Implementiamo un programma Java per dimostrare l'uso dell'interfaccia Iterator. Il seguente programma crea un ArrayList di fiori. Quindi ottiene un iteratore utilizzando il metodo iterator () di ArrayList. Dopodiché, l'elenco viene attraversato per visualizzare ogni elemento.

import java.util.*; public class Main { public static void main(String() args) { List flowers = new ArrayList(); flowers.add('Rose'); flowers.add('Jasmine'); flowers.add('sunflower'); // Get Iterator IteratorflowersIterator = flowers.iterator(); System.out.println('Contents of ArrayList:'); // Traverse elements using iterator while(flowersIterator.hasNext()){ System.out.print(flowersIterator.next() + ' '); } } }

Produzione:

Esempio di iteratore

Limitazioni dell'interfaccia Iterator

  • L'operazione per sostituire un elemento o aggiungere un nuovo elemento non può essere eseguita con questo Iteratore.
  • L'iterazione procede solo in una direzione, ovvero la direzione in avanti.
  • Supporta solo l'iterazione sequenziale.
  • Quando devono essere iterati grandi volumi di dati, le prestazioni di Iterator ne risentono.

Iteratore VsIterabile

Sebbene le interfacce Iterable e Iterator suonino simili, sono completamente diverse. Una classe che implementa l'interfaccia Iterable acquisisce la capacità di iterare sugli oggetti classe che utilizzano l'interfaccia iteratore.

Di seguito sono riportate alcune delle principali differenze tra queste due interfacce di cui devi essere a conoscenza:

Interfaccia iterabile Interfaccia iteratore
Rappresenta una raccolta che può essere attraversata utilizzando il ciclo foreach.Permette di scorrere su qualche altra raccolta.
La classe che implementa l'interfaccia iterabile deve sovrascrivere il metodo iterator ().I metodi hasNext () e next () dell'interfaccia Iterator devono essere sovrascritti dalla classe che li implementa.
Non memorizza lo stato corrente.Memorizza lo stato corrente dell'iterazione.
Un'istanza dell'interfaccia iteratore dovrebbe essere prodotta ogni volta che viene chiamato il metodo iterator ().Nessun contratto di questo tipo per l'interfaccia dell'iteratore.
Si muove solo in avanti.Si sposta in avanti e le sottointerfacce come listIterator supportano l'attraversamento bidirezionale.
Non fornisce alcun metodo per modificare gli elementi durante l'iterazione.Fornisce il metodo di rimozione che può rimuovere l'elemento quando l'iterazione è in corso.

Interfaccia ListIterator in Java

L'interfaccia ListIterator è una sottointerfaccia dell'interfaccia dell'iteratore. Funziona su raccolte di tipi di elenchi come Linkedlists, elenchi di array, ecc. Quindi questa interfaccia supera le carenze dell'interfaccia Iterator.

Le caratteristiche principali dell'interfaccia ListIterator includono:

  • L'interfaccia ListIterator estende l'interfaccia Iterator.
  • L'interfaccia ListIterator supporta le operazioni CRUD, ad esempio Crea, Leggi, Aggiorna ed Elimina.
  • Supporta l'iterazione sia in avanti che all'indietro.
  • Poiché questa interfaccia è bidirezionale, il cursore è sempre posizionato tra l'elemento precedente e quello successivo.
  • Questa interfaccia funziona principalmente per implementazioni di elenchi come ArrayList, LinkedList, ecc.
  • Disponibile da Java 1.2

L'interfaccia ListIterator è rappresentata come mostrato di seguito:

Rappresentazione ListIterator dell

Come già accennato, l'interfaccia ListIterator estende l'interfaccia Iterator. Pertanto, oltre a supportare tutti i metodi dell'interfaccia iteratore, come illustrato sopra l'interfaccia ListIterator ha anche metodi propri che lo aiutano a eseguire operazioni CRUD e iterazioni bidirezionali.

Parliamo in dettaglio dei metodi ListIterator.

Metodi ListIterator

Si noti che i metodi dell'interfaccia Iterator, next (), hasNext () e remove () funzionano esattamente allo stesso modo dell'interfaccia ListIterator. Quindi, ignoreremo questi metodi in questa sezione. Oltre ai metodi sopra menzionati, ListIterator ha i seguenti metodi:

Precedente()

Prototipo: E precedente ()
Parametri: NIL
Tipo di ritorno:
E- elemento precedente nell'elenco.
- 1 - se l'iteratore è all'inizio della lista.

Descrizione: Questa funzione restituisce l'elemento precedente nell'elenco. Una volta restituito l'elemento precedente, il cursore viene spostato all'indietro sull'elemento successivo.

hasPrevious ()

Prototipo: booleano hasPrevious ()
Parametri: NIL
Tipo di ritorno: true => l'iteratore ha più elementi quando l'elenco viene spostato all'indietro.

Descrizione: Questa funzione controlla se ListIterator ha più elementi nella direzione all'indietro.

previousIndex

Prototipo: int previousIndex ()
Parametri: NIL
Tipo di ritorno:
int - indice dell'elemento precedente
- 1 - se il puntatore è all'inizio dell'elenco.

Descrizione: Restituisce l'indice dell'elemento precedente restituito dalla chiamata previous ().

nextIndex

Prototipo: int nextIndex ()
Parametri: NIL
Tipo di ritorno:
int - indice successivo
- 1 - se l'iteratore è alla fine della lista.

Descrizione: Restituisce l'indice successivo dell'elemento nell'elenco. Questo elemento viene restituito da una chiamata al metodo next ().

impostato()

Prototipo: void set(E e)
Parametri: e - elemento da sostituire
Tipo di ritorno: NIL

Descrizione: Utilizzato per sostituire l'ultimo elemento con l'elemento specificato e.

Inserisci()

Prototipo: void add(E e)
Parametri: e - elemento da aggiungere
Tipo di ritorno: NIL

Descrizione: Aggiunge nuovi elementi all'elenco in una posizione precedente a quella dell'elemento next ().

Esempio di iteratore elenco

Ora sappiamo cos'è un ListIterator e quali sono i vari metodi supportati da esso. Andiamo avanti e implementiamo un programma Java per dimostrare ListIterator.

In questo programma, abbiamo utilizzato ArrayList. Quindi usiamo i metodi ListIterator per attraversare l'elenco nella direzione avanti e indietro e visualizzare l'output.

import java.util.*; class Main { public static void main(String args()) { Listnum_list = new ArrayList(); // Add Elements to ArrayList num_list.add(1); num_list.add(3); num_list.add(5); num_list.add(7); num_list.add(9); // Creatinge a ListIterator ListIteratorlist_it = num_list.listIterator(); System.out.println('Output using forward iteration:'); while (list_it.hasNext()) System.out.print(list_it.next()+' ') ; System.out.print(' Output using backward iteration: ') ; while (list_it.hasPrevious()) System.out.print(list_it.previous()+' '); } }

Produzione:

ListIterator - Output

Finora abbiamo discusso le interfacce, l'iteratore e il Listiterator, di seguito vedremo i vari esempi di utilizzo di queste interfacce per attraversare raccolte diverse. Ma prima, esaminiamo l'attraversamento di semplici array e poi passiamo ad altre raccolte.

Iteratore di array

In Java, ci sono due modi per iterare sugli elementi dell'array. Descriviamo i modi in cui utilizzare esempi di codice.

# 1) per loop

Questo è il modo più semplice di iterare su un array. Usiamo un semplice ciclo for che incrementerà l'indice ad ogni iterazione e ne visualizzerà il contenuto.

import java.util.*; public class Main { public static void main(String() args) { int myArray() = {2,4,6,8,10,12,14}; int num; System.out.println('Array contents using for loop:'); for (int i = 0; i

Produzione:

Iteratore di array per loop

Il programma sopra mostra il contenuto dell'array usando il ciclo for.

# 2) forEach ciclo

Questo è il secondo modo per iterare sugli array. Qui utilizziamo un ciclo for specializzato o 'forEach'. Qui eseguiamo un ciclo attraverso l'array per ogni elemento e quindi visualizziamo il contenuto.

import java.util.*; public class Main { public static void main(String() args) { int myArray() = {2,4,6,8,10,12,14}; int num; System.out.println('Array contents using for each loop:'); for (int i :myArray) { // accessing each element of array num = i; System.out.print(num + ' '); } } }

Produzione:

Iteratore di array - output

Il forEach è più ottimizzato rispetto al ciclo for. È più breve da digitare ed è anche più veloce.

ArrayList Iterator

Nel caso in cui desideri attraversare una raccolta ArrayList, puoi farlo utilizzando l'interfaccia Iterator. Poiché l'iteratore è un'interfaccia, non è possibile istanziarla direttamente. Invece, puoi utilizzare il metodo iterator () della raccolta ArrayList per ottenere l'iteratore e quindi attraversare l'elenco.

Iterator iterator ();

Esempio per dimostrare ArrayList Iterator.

import java.util.*; public class Main { public static void main(String() args) { ArrayListmyList = new ArrayList(); myList.add('Red'); myList.add('Green'); myList.add('Blue'); myList.add('Brown'); myList.add('Pink'); myList.add('Purple'); Iteratorlist_it = myList.iterator(); System.out.println('Elements in the arrayList:'); while(list_it.hasNext()) System.out.print(list_it.next() + ' '); } }

Produzione:

ArrayList Iterator

LinkedList Iterator

Vediamo ora la funzionalità di un iteratore in caso di raccolta LinkedList.

La raccolta LinkedList supporta il metodo listIterator () che restituisce listIterator per attraversare l'elenco collegato.

Il formato generale per questa funzione è

ListIterator list_iter = LinkedList.listIterator (int index);

In questo caso, l'indice è un valore intero che specifica la posizione nella raccolta della lista collegata da cui deve iniziare l'attraversamento.

Cerchiamo di capire l'iteratore della lista nella lista collegata con un programma di esempio. Abbiamo modificato lo stesso programma iteratore di array e lo abbiamo cambiato per contenere un listiterator con LinkedList.

import java.util.*; public class Main { public static void main(String() args) { LinkedListmyList = new LinkedList(); myList.add('Red'); myList.add('Green'); myList.add('Blue'); myList.add('Brown'); myList.add('Pink'); myList.add('Purple'); ListIteratorlist_it = myList.listIterator(0); System.out.println('Elements in the LinkedList:'); while(list_it.hasNext()) System.out.print(list_it.next() + ' '); } }

Produzione:

come scrivere storie utente e criteri di accettazione

Iteratore LinkedList - output

Java Map / Hashmap Iterator

La mappa o le sue varianti come hashmap, treemap, ecc. Non sono raccolte. Quindi non è possibile utilizzare direttamente il metodo iteratore su di esso. Invece, dovresti iterare sui valori della voce chiave per leggere le coppie chiave / valore.

Sebbene sia possibile utilizzare vari metodi come forEach, ciclo for, ecc. Per eseguire l'iterazione sui valori della mappa, l'utilizzo di un iteratore per scorrere i valori chiave è il metodo migliore ed efficiente. Inoltre, puoi anche rimuovere le voci dalla mappa durante l'iterazione utilizzando il metodo di rimozione.

Esempio di utilizzo di Iterator con HashMap.

import java.util.*; class Main { public static void main(String() arg) { MapmyMap = new HashMap(); // enter name/url pair myMap.put(1, 'India'); myMap.put(2, 'Nepal'); myMap.put(3, 'Maldives'); myMap.put(4, 'SriLanka'); System.out.println(' SAARC Member Countries '); System.out.println(' KEY' + ' ' + ' COUNTRY' ); // using iterators Iteratormap_itr = myMap.entrySet().iterator(); while(map_itr.hasNext()) { Map.Entrymap_entry = map_itr.next(); System.out.println(' ' + map_entry.getKey() + ' ' + map_entry.getValue()); } } }

Produzione:

Iteratore hashmap Javamap

Nel programma precedente, abbiamo definito una mappa con chiavi intere e valori di tipo stringa. Quindi definiamo un iteratore sulla mappa. Immettere e visualizzare le coppie chiave / valore.

Java Set Iterator

Il metodo iterator () di Java.util.set viene utilizzato per ottenere l'iteratore che restituisce gli elementi dell'insieme in ordine casuale.

Iterator set_iterator = Set.iterator();

Il 'set_iterator' itera sui diversi elementi dell'insieme e restituisce i loro valori.

In modo simile, il set di hash contiene anche una funzione iteratore che restituisce un iteratore come un iteratore di set.

Iterator hashset_iterator = Hash_Set.iterator();

Di seguito è riportato l'esempio di programmazione per dimostrare l'iteratore set.

import java.util.*; public class Main { public static void main(String args()) { HashSetsports_set = new HashSet(); sports_set.add('Hocky'); sports_set.add('Kabaddi'); sports_set.add('Football'); sports_set.add('Badminton'); sports_set.add('Cricket'); System.out.println('Sports HashSet: ' + sports_set); // Creating an iterator Iterator hashset_iter = sports_set.iterator(); // Displaying the values after iterating through the set System.out.println(' SportsSet iterator values:'); while (hashset_iter.hasNext()) { System.out.println(hashset_iter.next()); } } }

Produzione:

Java set iterator

Questa implementazione utilizza l'estensione Iteratore HashSet e visualizza i singoli valori iterando sugli elementi HashSet.

Iterator vs ListIterator

Tabularizziamo le principali differenze tra le interfacce Iterator e ListIterator.

Iteratore ListIterator
Può attraversare tutte le collezioni inclusi set, mappa, ecc.Può essere utilizzato per attraversare solo raccolte di tipi di elenchi come ArrayList, LinkedList.
Itera la raccolta solo nella direzione in avanti.Può scorrere la raccolta sia in avanti che all'indietro.
Impossibile ottenere gli indici.Può ottenere indici.
Nessun modo per aggiungere nuovi elementi alla collezione.Puoi aggiungere nuovi elementi alla raccolta.
L'iteratore non può modificare gli elementi durante l'iterazione.ListIterator può modificare gli elementi nella raccolta utilizzando il metodo set ().

Domande frequenti

D # 1) Qual è l'iterazione in Java?

Risposta: Un'iterazione è un processo mediante il quale un blocco di codice viene eseguito ripetutamente fino a quando una determinata condizione non si mantiene o non esiste. Utilizzando l'iterazione è possibile attraversare una sequenza di elementi o elaborare i dati.

D # 2) Quanti tipi di iteratori ci sono in Java?

Risposta: Gli iteratori vengono utilizzati per attraversare le raccolte in Java.

Esistono tre tipi di iteratori in Java:

  • Enumeratori
  • Iteratori
  • ListIterators

D # 3) Come si usa un iteratore in Java?

Risposta: Per utilizzare l'iteratore per attraversare la raccolta, prima devi ottenere l'iteratore utilizzando il metodo iterator () della raccolta specificata.

Quindi puoi usare i metodi hasNext () e next () dell'iteratore per ottenere l'elemento.

D # 4) Perché viene utilizzato Iterator al posto del ciclo for?

Risposta: Sia l'iteratore che il ciclo for vengono utilizzati per eseguire ripetutamente un blocco di codice specifico. Ma la differenza principale è che nel ciclo for non è possibile alterare o modificare il contenuto della raccolta. Anche se si tenta di modificarlo, verrà generata concurrentModificationException. Usando l'iteratore puoi rimuovere un elemento dalla collezione.

D # 5) Perché abbiamo bisogno di Iterator in Java?

Risposta: Iterator ti aiuta a recuperare gli elementi nella collezione o in un contenitore senza che il programmatore debba conoscere la struttura interna o il funzionamento della collezione. Sono più eleganti, consumano meno memoria e anche il programmatore è risparmiato nella scrittura di codice lungo.

In secondo luogo, gli elementi possono essere memorizzati nella raccolta in qualsiasi modo, ma utilizzando un iteratore, il programmatore può recuperarli proprio come un elenco o qualsiasi altra sequenza.

Conclusione

In questo tutorial abbiamo discusso gli iteratori in Java utilizzati con le raccolte. Questa conoscenza degli iteratori aiuterà i lettori a cogliere le raccolte che impareremo nei nostri successivi tutorial.

Lettura consigliata

^