Un cursore Java è un iteratore, utilizzato per iterare, attraversare o recuperare gli elementi di un oggetto Collection o Stream uno per uno. In questo articolo impareremo a conoscere gli iteratori Java e come funziona.

Tipi di cursori in Java

Ci sono tre cursori in Java come indicato di seguito:

1. Iteratore
2. Enumerazione
3. ListIterator

Nota: SplitIterator può anche essere considerato un cursore poiché è solo un tipo di Iterator.

1. Iteratore

Gli iteratori in Java vengono utilizzati in Quadro della raccolta per recuperare gli elementi uno per uno. È un universale iteratore poiché possiamo applicarlo a qualsiasi oggetto Collection. Utilizzando Iterator, possiamo eseguire sia operazioni di lettura che di rimozione. È una versione migliorata di Enumerazione con la funzionalità aggiuntiva di rimozione di un elemento.

Iterator deve essere utilizzato ogni volta che vogliamo enumerare elementi in tutte le interfacce implementate nel framework Collection come Set, List, Queue, Deque e tutte le classi implementate dell'interfaccia Map. L'iteratore è il soltanto cursore disponibile per l'intero framework della raccolta. Un oggetto iteratore può essere creato chiamando il metodo iteratore() metodo presente nell'interfaccia Collection.

Sintassi

Iterator itr = c.  iterator  ();>

Nota: Qui c è qualsiasi oggetto Collection. itr è di tipo interfaccia Iterator e si riferisce a c.

stringhe di ordinamento Java

Metodi di interfaccia Iterator in Java

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

1. hasNext(): Restituisce vero se l'iterazione ha più elementi.

public boolean hasNext();>

2. successivo(): Restituisce l'elemento successivo nell'iterazione. Lancia NoSuchElementException se non è presente più alcun elemento.

public Object next();>

3. rimuovi(): Rimuove l'elemento successivo nell'iterazione. Questo metodo può essere chiamato solo una volta per chiamata a next().

public void remove();>

Nota: rimuovere() Il metodo può generare due eccezioni, vale a dire come segue:

• Eccezione operazione non supportata : Se l'operazione di rimozione non è supportata da questo iteratore
• IllegalStateException : Se il metodo successivo non è stato ancora chiamato oppure il metodo di rimozione è già stato chiamato dopo l'ultima chiamata al metodo successivo.

Come funziona internamente Java Iterator?

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

List cities = new LinkedList();  cities.add('G-1');  cities.add('G-2');  cities.add('G-3');  .  .  .  cities.add('G-n');>

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

Iterator citiesIterator = cities.iterator();>

L'iteratorecityIteartor sarà simile a questo:

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

ordinamento delle tuple Python

Ora eseguiremo il seguente frammento di codice.

citiesIterator.hasNext(); citiesIterator.next();>

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

Ora eseguiremo il seguente frammento di codice.

citiesIterator.hasNext(); citiesIterator.next();>

Quando eseguiamo lo snippet di codice sopra, il cursore di Iterator punta al secondo elemento nell'elenco come mostrato nel diagramma sopra. Esegui questo processo per raggiungere il cursore dell'iteratore sull'elemento finale dell'elenco.

Dopo aver letto l'elemento finale, se eseguiamo lo snippet di codice seguente, restituisce un valore falso.

citiesIterator.hasNext();>

Poiché il cursore dell'Iterator punta dopo l'elemento finale della Lista, il metodo hasNext() restituisce un valore falso.

Nota: Dopo aver osservato tutti questi diagrammi, possiamo dire che Java Iterator supporta solo l'iterazione della direzione in avanti, come mostrato nel diagramma seguente. Quindi è anche noto come cursore unidirezionale.

Esempio

// Java program to Demonstrate Iterator // Importing ArrayList and Iterator classes // from java.util package import java.util.ArrayList; import java.util.Iterator; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating an ArrayList class object // Declaring object of integer type ArrayList al = nuovo ArrayList (); // Iterando sulla Lista for (int i = 0; i< 10; i++) al.add(i); // Printing the elements in the List System.out.println(al); // At the beginning itr(cursor) will point to // index just before the first element in al Iterator itr = al.iterator(); // Verifica l'elemento successivo dove // ​​la condizione rimane vera finché non c'è un singolo elemento // nell'elenco utilizzando il metodo hasnext() while (itr.hasNext()) { // Spostamento del cursore sull'elemento successivo int i = itr.next( ); // Ottenere gli elementi uno per uno System.out.print(i + ' '); // Rimozione degli elementi dispari if (i % 2 != 0) itr.remove(); } // Comando per la riga successiva System.out.println(); // Stampa gli elementi all'interno dell'oggetto System.out.println(al); } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9 [0, 2, 4, 6, 8]>

SplitIterator

Gli spliter, come gli altri iteratori, servono per attraversare gli elementi di una sorgente. Una fonte può essere a Collezione , un canale IO o una funzione generatore. È incluso in JDK 8 per il supporto di un efficiente attraversamento parallelo (programmazione parallela) oltre all'attraversamento sequenziale. L'interfaccia Java Spliterator è un iteratore interno che suddivide il flusso in parti più piccole. Queste parti più piccole possono essere lavorate in parallelo.

Nota: Nella programmazione nella vita reale, potremmo non aver mai bisogno di utilizzare direttamente Spliterator. Durante le normali operazioni, si comporterà esattamente come Java Iterator.

Vantaggi di Java Iterator

• Possiamo usarlo per qualsiasi classe Collection.
• Supporta entrambe le operazioni READ e REMOVE.
• È un cursore universale per l'API di raccolta.
• I nomi dei metodi sono semplici e facili da usare.

Limitazioni di Java Iterator

Inoltre, ci sono alcune limitazioni di Iterator elencate di seguito:

• Nelle operazioni CRUD, NON supporta le operazioni CREATE e UPDATE.
• Supporta solo l'iterazione della direzione in avanti che è un iteratore unidirezionale.
• Rispetto a Spliterator, NON supporta l'iterazione parallela degli elementi, il che significa che supporta solo l'iterazione sequenziale.
• Rispetto a Spliterator, NON supporta prestazioni migliori per l'iterazione di grandi volumi di dati.

2. Enumerazione

È un'interfaccia utilizzata per ottenere elementi di raccolte legacy (Vector, Hashtable). L'enumerazione è il primo iteratore presente da JDK 1.0, i resti sono inclusi in JDK 1.2 con più funzionalità. Le enumerazioni vengono utilizzate anche per specificare i flussi di input in a SequenceInputStream . Possiamo creare un oggetto Enumerazione chiamando elementi() metodo della classe vettoriale su qualsiasi oggetto vettoriale

Sintassi

// Here 'v' is an Vector class object. e is of // type Enumeration interface and refers to 'v' Enumeration e =   v  .  elements  ();>

Ci sono due metodi nell'interfaccia di enumerazione vale a dire:

1. booleano pubblico hasMoreElements(): Questo metodo verifica se questa enumerazione contiene più elementi o meno.

2. Oggetto pubblico nextElement(): Questo metodo restituisce l'elemento successivo di questa enumerazione. Genera NoSuchElementException se non sono presenti più elementi

Esempio

// Java program to demonstrate Enumeration // Importing Enumeration and Vector classes // from java.util package import java.util.Enumeration; import java.util.Vector; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating a vector object Vector v = new Vector(); // Iterating over vector object for (int i = 0; i < 10; i++) v.addElement(i); // Printing elements in vector object System.out.println(v); // At beginning e(cursor) will point to // index just before the first element in v Enumeration e = v.elements(); // Checking the next element availability where // condition holds true till there is a single // element // remaining in the List while (e.hasMoreElements()) { // Moving cursor to next element int i = (Integer)e.nextElement(); // Print above elements in object System.out.print(i + ' '); } } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9>

Esistono alcune limitazioni di enumerazione che sono le seguenti:

• L'enumerazione è per eredità solo classi (Vector, Hashtable). Quindi non è un iteratore universale.
• Le operazioni di rimozione non possono essere eseguite utilizzando l'enumerazione.
• È possibile solo l'iterazione in direzione avanti.

Somiglianze tra l'enumerazione Java e l'iteratore

• Entrambi sono cursori Java.
• Entrambi vengono utilizzati per ripetere una raccolta di elementi oggetto uno per uno.
• Entrambi supportano l'operazione READ o Recupero.
• Entrambi sono cursori Java unidirezionali, il che significa che supportano solo l'iterazione della direzione in avanti.

Differenze tra l'enumerazione Java e l'iteratore

La tabella seguente descrive le differenze tra l'enumerazione Java e l'iteratore:

3. ListIterator

È applicabile solo per le classi implementate della raccolta List come ArrayList, LinkedList, ecc. Fornisce l'iterazione bidirezionale. ListIterator deve essere utilizzato quando vogliamo enumerare elementi di List. Questo cursore ha più funzionalità (metodi) dell'iteratore. L'oggetto ListIterator può essere creato chiamando elencoIteratore() metodo presente nell'interfaccia List.

Sintassi

ListIterator ltr = l.  listIterator  ();>

Nota: Qui l è qualsiasi oggetto List, ltr è di tipo. Interfaccia ListIterator e si riferisce a l. L'interfaccia ListIterator estende l'interfaccia Iterator. Quindi tutti e tre i metodi dell'interfaccia Iterator sono disponibili per ListIterator. Inoltre, ci sono sei più metodi.

1. Direzione in avanti

1.1 haNext(): Restituisce vero se l'iterazione ha più elementi

public boolean hasNext();>

1.2 successivo(): Uguale al metodo next() di Iterator. Restituisce l'elemento successivo nell'iterazione.

public Object next();>

1.3 nextIndice(): Restituisce l'indice dell'elemento successivo o la dimensione dell'elenco se l'iteratore dell'elenco si trova alla fine dell'elenco.

public int nextIndex();>

2. Direzione indietro

2.1 haPrecedente(): Restituisce vero se l'iterazione ha più elementi durante l'attraversamento all'indietro.

public boolean hasPrevious();>

2.2 precedente(): Restituisce l'elemento precedente nell'iterazione e può lanciare un'eccezione NoSuchElementException se non è più presente alcun elemento.

public Object previous();>

2.3 Indice precedente(): Restituisce l'indice dell'elemento precedente o -1 se l'iteratore della lista è all'inizio della lista,

alfabeto con numeri

public int previousIndex();>

3. Altri metodi

3.1 rimuovi(): Uguale al metodo Remove() di Iterator. Rimuove l'elemento successivo nell'iterazione.

public void remove();>

3.2 set(Oggetto oggetto): Sostituisce l'ultimo elemento restituito da next() o previous() con l'elemento specificato.

public void set(Object obj);>

3.3 aggiungi(Oggetto oggetto): Inserisce l'elemento specificato nella lista nella posizione prima dell'elemento che verrebbe restituito da next()

public void add(Object obj);>

Chiaramente, i tre metodi che ListIterator eredita da Iterator ( haNext() , Prossimo() , E rimuovere() ) fanno esattamente la stessa cosa in entrambe le interfacce. IL haPrecedente() e le operazioni precedenti ne sono esatte analoghe haNext() E Prossimo() . Le prime operazioni si riferiscono all'elemento prima del cursore (implicito), mentre le seconde si riferiscono all'elemento dopo il cursore. L'operazione precedente sposta il cursore indietro, mentre quella successiva lo sposta in avanti.

ListIterator non ha elementi correnti; la posizione del cursore si trova sempre tra l'elemento che verrebbe restituito da una chiamata a precedente() e l'elemento che verrebbe restituito da una chiamata a Prossimo().

1 set() il metodo può generare 4 eccezioni.

• Eccezione operazione non supportata: se l'operazione set non è supportata da questo iteratore elenco
• ClassCastException: Se la classe dell'elemento specificato impedisce che venga aggiunto a questo elenco
• IllegalArgumentException: Se qualche aspetto dell'elemento specificato impedisce che venga aggiunto a questo elenco
• IllegalStateException: Se non sono stati chiamati né il successivo né il precedente, oppure rimuovere o aggiungere sono stati chiamati dopo l'ultima chiamata al successivo o al precedente

2. aggiungi() il metodo può generare 3 eccezioni.

convertire la stringa in carattere

• Eccezione operazione non supportata: Se il metodo add non è supportato da questo iteratore dell'elenco
• ClassCastException: Se la classe dell'elemento specificato impedisce che venga aggiunto a questo elenco
• IllegalArgumentException: Se qualche aspetto di questo elemento impedisce che venga aggiunto a questo elenco

Esempio

// Java program to demonstrate ListIterator // Importing ArrayList and List iterator classes // from java.util package import java.util.ArrayList; import java.util.ListIterator; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating an object of ArrayList class ArrayList al = new ArrayList(); // Iterating over Arraylist object for (int i = 0; i < 10; i++) // Adding elements to the Arraylist object al.add(i); // Print and display all elements inside object // created above System.out.println(al); // At beginning ltr(cursor) will point to // index just before the first element in al ListIterator ltr = al.listIterator(); // Checking the next element availability while (ltr.hasNext()) { // Moving cursor to next element int i = (Integer)ltr.next(); // Getting even elements one by one System.out.print(i + ' '); // Changing even numbers to odd and // adding modified number again in // iterator if (i % 2 == 0) { // Change to odd i++; // Set method to change value ltr.set(i); // To add ltr.add(i); } } // Print and display statements System.out.println(); System.out.println(al); } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9 [1, 1, 1, 3, 3, 3, 5, 5, 5, 7, 7, 7, 9, 9, 9]>

Nota: Allo stesso modo, ci sono alcune limitazioni con ListIterator . È l'iteratore più potente ma è applicabile solo per le classi implementate in List, quindi non è un iteratore universale.

Punti importanti

1. Tieni presente che inizialmente qualsiasi riferimento all'iteratore punterà all'indice appena prima dell'indice del primo elemento in una raccolta.
2. Non creiamo oggetti di Enumerazione, Iterator, ListIterator perché sono interfacce. Usiamo metodi come elements(), iterator(), listIterator() per creare oggetti. Questi metodi hanno un anonimo Classe interiore che estende le rispettive interfacce e restituisce questo oggetto di classe.

Nota: IL $ Il simbolo nel nome della classe di riferimento è una prova che viene utilizzato il concetto di classi interne e che questi oggetti di classe vengono creati.

Questo può essere verificato dal codice seguente. Per ulteriori informazioni sulla classe interna fare riferimento

// Java program to demonstrate iterators references // Importing required classes from java.util package import java.util.Enumeration; import java.util.Iterator; import java.util.ListIterator; import java.util.Vector; // Main class public class GFG { // Main driver method public static void main(String[] args) { // Creating an object of Vector class Vector v = new Vector(); // Creating three iterators Enumeration e = v.elements(); Iterator itr = v.iterator(); ListIterator ltr = v.listIterator(); // Print class names of iterators // using getClass() and getName() methods System.out.println(e.getClass().getName()); System.out.println(itr.getClass().getName()); System.out.println(ltr.getClass().getName()); } }>

java.util.Vector java.util.Vector$Itr java.util.Vector$ListItr>

Spiegazione

In Java, un iteratore è un'interfaccia utilizzata per attraversare una raccolta di oggetti uno per uno. Viene utilizzato per scorrere qualsiasi struttura di dati basata su raccolte, inclusi array, elenchi, set e mappe.

Un iteratore ha tre metodi principali utilizzati per attraversare la raccolta:

• hasNext() – Questo metodo controlla se c'è un altro elemento nella raccolta su cui è possibile eseguire l'iterazione.
• next() – Questo metodo restituisce l'elemento successivo nella raccolta.
• rimuovi() – Questo metodo rimuove l'elemento corrente dalla raccolta.
  

L'interfaccia Iterator fa parte del Java Collection Framework ed è implementata dalle classi che rappresentano i diversi tipi di raccolte.

Programma

import java.util.ArrayList; import java.util.Iterator; public class IteratorExample { public static void main(String[] args) { ArrayListnomi = nuovo ArrayList(); nomi.add('Alice'); nomi.add('Bob'); nomi.add('Charlie'); nomi.add('Davide'); // Creazione di un iteratore per l'elenco dei nomi Iteratoriteratore = nomi.iteratore(); // Iterazione sull'elenco dei nomi utilizzando l'iteratore while (iterator.hasNext()) { String name = iterator.next(); System.out.println(nome); } } }>

Alice Bob Charlie David>

In questo esempio, abbiamo creato un ArrayList di stringhe e vi abbiamo aggiunto quattro nomi. Abbiamo quindi creato un iteratore per la lista utilizzando il metodo iterator() della classe ArrayList. Abbiamo utilizzato il metodo hasNext() per verificare se ci sono più elementi nell'elenco su cui eseguire l'iterazione e il metodo next() per ottenere l'elemento successivo nell'elenco. Abbiamo stampato ogni elemento utilizzando il metodo System.out.println().

L'uso di un iteratore per attraversare una raccolta è un modo comodo ed efficiente di scorrere la raccolta perché consente di scorrere la raccolta senza conoscere la struttura interna della raccolta. Consente inoltre la rimozione di elementi dalla raccolta durante l'iterazione su di essa.

Vantaggi di Iterator in Java:

• L'Iterator è un'interfaccia semplice e facile da usare che ci consente di attraversare una raccolta senza esporre la sua implementazione sottostante.
• L'Iterator è un modo efficiente per scorrere una raccolta, soprattutto quando disponiamo di una grande quantità di dati.
• L'Iterator fornisce un modo sicuro per rimuovere elementi da una raccolta durante l'iterazione senza causare eccezioni di modifica simultanee.
• L'interfaccia Iterator è implementata da tutte le classi di raccolta in Java, quindi possiamo utilizzare lo stesso codice per scorrere diversi tipi di raccolte.

Svantaggi di Iterator in Java:

Esistono alcuni svantaggi nell'utilizzo di Iterator in Java, come indicato di seguito:

• L'Iterator è un'interfaccia unidirezionale, il che significa che possiamo solo andare avanti attraverso una raccolta. Non possiamo tornare indietro o saltare a un elemento specifico.
• L'Iterator non è thread-safe, quindi non possiamo usarlo per scorrere una raccolta in un ambiente multi-thread senza un'adeguata sincronizzazione.
• L'Iterator non fornisce alcun meccanismo per modificare gli elementi durante l'iterazione su una raccolta, a parte la rimozione degli elementi. Se dobbiamo modificare degli elementi, dobbiamo utilizzare altre interfacce come ListIterator o un semplice ciclo for.