Introduzione a Iterator in Java
Un Iterator è un'interfaccia che viene utilizzata per recuperare gli elementi uno per uno in una raccolta. È disponibile nel pacchetto Java chiamato Java. pacchetto util. L'API di raccolta implementa il metodo iterator () e quindi i dati possono essere recuperati da interfacce come Map, List, Queue, Deque e Set che sono tutti implementati dal framework di raccolta. Come suggerisce il nome, un iteratore in Java scorre attraverso una raccolta di oggetti.
Sintassi:
Iterator iterator()
Sotto l'iteratore si trova il nome di un oggetto creato chiamando il metodo iterator () dell'interfaccia di raccolta. "Collection" è il nome dell'oggetto collection.
Iterator iter = collection.iterator();
Metodi di Iterator in Java
Gli iteratori hanno 4 metodi in Java che vengono utilizzati per attraversare raccolte e recuperare le informazioni richieste. Sono i seguenti:
- hasNext (): questo è un metodo che restituisce true booleano se l'iterazione presenta un elemento successivo presente e booleano false se non è presente alcun elemento successivo.
- next (): questo metodo restituisce il valore dell'elemento presente nella prossima iterazione. Supponiamo che non ci siano elementi da restituire nella successiva iterazione, quindi viene lanciata una "NoSuchElementException".
- remove (): questo metodo rimuove l'elemento presente restituito dall'iteratore dalla raccolta. Nel caso in cui questo metodo sia chiamato metodo precedente al successivo (), genera "IllegalStateException".
- forEachRemaining (): questo metodo esegue l'operazione su tutti gli elementi rimanenti nella raccolta fino a quando non sono stati elaborati tutti o fino a quando non viene generata un'eccezione. Inoltre, questo è un metodo recentemente introdotto da Oracle Corporation nella loro versione Java SE 8.
Esempio di Iteratore in Java
Di seguito è riportato l'esempio di Iterator in Java:
Codice:
import java.io.*;
import java.util.*;
public class IteratorExample (
public static void main(String() args)
(
ArrayList val = new ArrayList();
val.add("Iteration started");
val.add("Printing iteration1");
val.add("Printing iteration2");
val.add("Printing iteration3");
val.add("End of iteration");
// Iterates through the list
Iterator iter = val.iterator();
System.out.println("The values of iteration are as follows: ");
while (iter.hasNext())
System.out.println(iter.next() + " ");
System.out.println();
)
)
Produzione:
Eccezioni generate dai metodi Iterator
In un elenco di elementi, un iteratore può recuperare informazioni solo sugli elementi esistenti. Si arresta in modo anomalo o genera un'eccezione se si tenta di accedere a un elemento che non è presente nella successiva iterazione. Qui dovremo conoscere i diversi tipi di eccezioni che otteniamo durante l'implementazione dei metodi iteratori.
1. metodo next ()
Durante l'iterazione di un set di elementi e il loro recupero con questo metodo, può verificarsi la seguente eccezione.
- NoSuchElementException: questo si verifica se next () tenta di recuperare un elemento che non esiste nel presente elenco. Quindi è sempre necessario utilizzare hasNext () prima di chiamare next ().
2. metodo remove ()
Esistono 2 tipi di eccezioni che possono verificarsi qui:
- IllegalStateException: se il metodo remove () viene chiamato prima del metodo next (), viene generata questa eccezione. Questo perché il metodo tenta di rimuovere un elemento che non è stato ancora specificato dal metodo next () e quindi non riesce. Per risolvere questa eccezione, next () deve essere chiamato per fare riferimento al primo elemento e quindi remove () può essere chiamato per rimuovere lo stesso dall'elenco.
- UnsupportedOperationException: questa eccezione viene generalmente generata quando si tenta di modificare un oggetto elenco mediante un'operazione di aggiunta o rimozione che non supporta la modifica. Ad esempio, quando un array viene tentato di convertire in un elenco da Arrays.asList genera questa eccezione. Questo perché l'oggetto Elenco avrà una dimensione fissa in quanto viene creato dal wrapper da ArrayList e quindi la modifica non sarà consentita. Per risolvere questo problema, converti l'oggetto Arrays.asList in ArrayList o LinkedList prima di eseguire qualsiasi operazione come Aggiungi / Rimuovi sullo stesso.
Sintassi:
//ArrayList is created from the list having fixed size
list = new ArrayList(list);
Iterator iter = list.iterator();
while(iter.hasNext())(
if( iter.next().equals("First iteration") )(
iter.remove();
)
)
Metodi di ListIterator
Questi metodi consentono all'iteratore di attraversare entrambe le direzioni dell'oggetto di raccolta. Di seguito sono alcuni di loro:
- add (): questo metodo inserisce il valore dell'oggetto dato e viene restituito quando viene chiamato il metodo next ().
- hasNext (): questo metodo è uguale a quello menzionato nei tipi di iteratore che restituisce booleano true / false in base all'elemento successivo con un valore o meno.
- hasPrevious (): questo metodo è opposto a hasNext () e restituisce Boolean true se l'elenco ha un elemento precedente e viceversa.
- next (): questo metodo recupera l'elemento successivo dall'elenco indicato.
- previous (): questo metodo recupera l'elemento precedente dall'elenco.
- remove (): elimina l'elemento presente dall'elenco. Quando questo metodo viene chiamato prima della funzione next () o previous (), genera "IllegalStateException".
Esempio per ListIterator
Di seguito è riportato un esempio in ArrayList per ListIterator.
Codice:
import java.util.*;
public class IteratorExample (
public static void main(String args()) (
// Creating an array list
ArrayList array = new ArrayList();
// add elements to the array list
array.add("First element");
array.add("Second element");
array.add("Third element");
array.add("Fourth element");
array.add("Fifth element");
array.add("Sixth element");
// Displaying elements of an array
System.out.println("Printing input of the array: ");
Iterator iter = array.iterator();
while(iter.hasNext()) (
Object value = iter.next();
System.out.println(value + " ");
)
System.out.println();
// To update the elements of iteration
ListIterator listiter = array.listIterator();
while(listiter.hasNext()) (
Object value = listiter.next();
listiter.set(value + "+");
)
System.out.print("Updated array elements are as follows: ");
iter = array.iterator();
while(iter.hasNext()) (
Object value = iter.next();
System.out.print(value + " ");
)
System.out.println("\n");
// To display the contents in backward direction
System.out.println("Printing elements in backward direction: ");
while(listiter.hasPrevious()) (
Object value = listiter.previous();
System.out.print(value + " ");
)
System.out.println();
)
)
Produzione:
Vantaggi degli iteratori in Java
Di seguito sono riportati i vantaggi di Iteratori:
- Supporta tutte le classi nell'interfaccia Collection.
- I metodi di un iteratore sono abbastanza semplici e facili da capire e implementare.
- Gli elementi di una raccolta possono essere facilmente modificati (aggiungi / rimuovi) utilizzando Iteratori.
- L'accesso agli elementi tramite Iteratori non porterà a eccezioni di runtime.
- La gestione dei dati è efficiente.
- Può iterare contemporaneamente su varie variabili mantenendo lo stato di iterazione di ciascuna variabile separatamente.
Limitazioni di Iteratori in Java
Di seguito sono riportati i limiti di Iteratori:
- L'iteratore Java può iterare solo in una direzione, ovvero in avanti.
- Non può essere utilizzato per scorrere contemporaneamente tra due diverse strutture dati.
- Non può essere utilizzato per risalire a un elemento.
- Non consente la modifica della struttura dell'elemento iterato poiché ne memorizza la posizione.
- Potrebbe essere inefficiente in alcuni casi se attraversare gli elementi direttamente è più efficiente.
Conclusione
Gli iteratori sono il metodo più comunemente usato per recuperare elementi dall'interfaccia di raccolta. Si chiama Universal Java Cursor in quanto è applicabile in tutte le classi Collection.
Articolo raccomandato
Questa è una guida a Iterator in Java. Qui discutiamo i metodi e gli esempi di Iterator in Java insieme ai suoi limiti e vantaggi. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più -
- Introduzione a Heap Sort in Java
- Sostituzione in Java (esempi)
- Iteratori in C # con vantaggi e svantaggi
- Le 10 domande principali per l'intervista alla raccolta Java
- Lancio contro Lancio | Le 5 differenze principali che dovresti conoscere