listiterator interface java with examples
Questo tutorial spiega l'interfaccia ListIterator in Java per attraversare le implementazioni degli elenchi. Imparerai a conoscere il diagramma delle classi e i metodi dell'interfaccia ListIterator:
Proprio come Iterator, l'interfaccia ListIterator fornisce la funzionalità per attraversare le implementazioni dell'elenco in Java e accedere agli elementi dell'elenco.
=> Controlla qui per vedere qui i tutorial di formazione su Java dalla A alla Z.
Cosa imparerai:
Interfaccia ListIterator in Java
Di seguito sono elencate alcune delle principali caratteristiche dell'interfaccia ListIterator:
- ListIterator è stato introdotto in Java 1.2
- ListIterator è una sotto-interfaccia dell'interfaccia Iterator, ovvero si estende dall'interfaccia Iterator.
- ListIterator funziona solo con le implementazioni di elenchi.
- ListIterator supporta tutte le operazioni, ovvero Crea, Leggi, Aggiorna ed Elimina. (Chiamate collettivamente operazioni CRUD).
- ListIterator è un iteratore bidirezionale e supporta iteratori di direzione sia in avanti che all'indietro.
- Nel caso di ListIterator, non è presente alcun elemento corrente. La posizione del cursore è puntata alla posizione tra l'elemento restituito dal metodo previous () e l'elemento che verrebbe restituito dal metodo next ().
Discutiamo di più su questa interfaccia in questo tutorial.
Diagramma della classe ListIterator
ListIterator è un'interfaccia che appartiene al framework API Collections. Questa interfaccia si estende dall'interfaccia Iterator. Oltre ad ereditare i metodi dell'interfaccia Iterator, supporta anche i metodi per le iterazioni bidirezionali e le operazioni CRUD.
Di seguito è mostrato il diagramma delle classi dell'interfaccia ListIterator.
La figura sopra mostra il diagramma delle classi dell'interfaccia ListIterator. Nella sezione successiva, discuteremo in dettaglio ciascuno dei metodi mostrati nella figura.
Metodi ListIterator
L'interfaccia ListIterator fornisce i seguenti metodi, come mostrato nella tabella seguente.
| Nome metodo | Prototipo | Descrizione |
|---|---|---|
| rimuovere() | void remove () | Rimuove l'ultimo elemento restituito dal metodo next () o previous (). |
| hasNext () | booleano hasNext () | Controlla se listIterator ha più elementi da attraversare in avanti. |
| Il prossimo() | E successivo () | Restituisce l'elemento successivo nell'elenco. Quindi sposta il cursore in modo che punti all'elemento successivo. |
| hasPrevious () | booleano hasPrevious () | Controlla se ListIterator ha più elementi nella direzione indietro / inversa. |
| precedente() | E precedente () | Restituisce l'elemento precedente nell'elenco e sposta il cursore in una posizione all'indietro. |
| nextIndex () | int nextIndex () | Restituisce l'indice dell'elemento che verrà restituito dalla chiamata al metodo next (). |
| previousIndex () | int previousIndex () | Restituisce l'indice dell'elemento che verrà restituito dalla chiamata al metodo previous (). |
| Sette) | void set(E e) | Sostituisce l'ultimo elemento restituito dal metodo next () o previous () con il nuovo valore. |
| add(E) | void add(E e) | Aggiunge un nuovo elemento all'elenco. |
Successivamente, descriveremo ciascuno di questi metodi in dettaglio.
# 1) hasNext ()
Prototipo: booleano hasNext ()
Parametri: NIL
Valore di ritorno:
- true => la lista contiene l'elemento successivo
- Falso => la lista non ha più elementi
Descrizione: Questo metodo controlla se ListIterator ha più elementi da attraversare nella direzione in avanti. Se ha più elementi, questo metodo restituisce true.
# 2) successivo ()
Prototipo: E successivo ()
Parametri: NIL
Valore di ritorno: E => elemento successivo nell'elenco.
Descrizione: Il metodo next () restituisce l'elemento successivo nell'elenco e sposta il cursore sull'elemento successivo.
Eccezione generata: NoSuchElementException - se ListIterator non ha un elemento successivo.
come trovare xpath in ie
# 3) hasPrevious ()
Prototipo: booleano hasPrevious ()
Parametri: NIL
Valore di ritorno: true => ListIterator ha l'elemento precedente
Descrizione: Controlla se ListIterator ha più elementi nella direzione indietro / inversa.
# 4) precedente ()
Prototipo: E precedente ()
Parametri: NIL
Valore di ritorno: E => elemento precedente nell'elenco
Descrizione: Questo metodo restituisce l'elemento precedente nell'elenco durante l'attraversamento all'indietro e quindi sposta il cursore all'indietro.
Eccezione generata: NoSuchElementException - se ListIterator non ha un elemento successivo.
# 5) nextIndex ()
Prototipo: int nextIndex ()
Parametri: NIL
Valore di ritorno: int => indice dell'elemento che verrà restituito dal metodo next () o dalla dimensione dell'elenco se ListIterator è alla fine dell'elenco.
Descrizione: Questo metodo può essere chiamato prima del metodo next (). Il metodo nextIndex () restituisce l'indice dell'elemento che verrà restituito dal metodo next (). Se ListIterator si trova alla fine dell'elenco, questo metodo restituisce la dimensione dell'elenco.
# 6) previousIndex ()
Prototipo: int previousIndex ()
Parametri: NIL
Valore di ritorno: int => indice dell'elemento che verrà restituito dal metodo previous () o -1 se ListIterator è all'inizio della lista.
Descrizione: Questo metodo può essere chiamato prima del metodo previous (). Il metodo previousIndex () restituisce l'indice dell'elemento che verrà restituito dal metodo previous (). Se ListIterator è all'inizio dell'elenco, il metodo restituisce -1.
# 7) rimuovi ()
Prototipo: void remove ()
Parametri: NIL
Valore di ritorno: vuoto
Descrizione: Il metodo remove () elimina l'ultimo elemento restituito dal metodo previous () o next (). La chiamata al metodo remove () può essere effettuata solo una volta per chiamata al metodo next () o previous ().
Eccezione generata:
- UnsupportedOperationException: ListIterator non supporta l'operazione di rimozione.
- IllegalStateException - Se l'operazione corrente è in stato Illegal, ovvero né la successiva né la precedente sono state ancora chiamate o dopo la chiamata alla successiva o alla precedente, l'aggiunta o la rimozione non sono stati chiamati.
# 8) imposta (E)
Prototipo: void set (E e)
Parametri: e => nuovo elemento con cui sostituire il vecchio elemento
Valore di ritorno: vuoto
Descrizione: Il metodo set () imposta l'elemento restituito dal metodo previous () o next () con il nuovo valore passato come argomento. Questo metodo può essere chiamato solo se il metodo add () o remove () non viene chiamato dopo l'ultima chiamata al metodo previous () o next ().
Eccezione generata:
- UnsupportedOperationException: ListIterator non supporta l'operazione di impostazione.
- ClassCastException - Se l'elemento specificato non può essere aggiunto a causa della sua classe.
- IllegalArgumentException: se l'elemento / argomento aggiunto è illegale o non valido.
- IllegalStateException - Se l'operazione corrente è in stato Illegal, ovvero né il successivo né il precedente sono stati ancora chiamati o dopo la chiamata al successivo o al precedente, aggiungi o rimuovi non sono stati chiamati.
#9) add(E)
Prototipo: void add(E e)
Parametri: e => nuovo elemento da aggiungere alla lista
Valore di ritorno: vuoto
Descrizione: Il metodo add () viene utilizzato per aggiungere un nuovo elemento all'elenco. L'elemento viene aggiunto appena prima dell'elemento che sarebbe stato restituito il next (), se presente, e dopo l'elemento che il metodo previous () avrebbe restituito.
Notare che, come risultato dell'aggiunta di un elemento, non ci sarebbe alcuna modifica per restituire il valore di next () ma il metodo previous () restituirà solo l'elemento aggiunto.
qual è il miglior youtube in mp3
Eccezione generata:
- UnsupportedOperationException - ListIterator non supporta il metodo di aggiunta.
- ClassCastException se un elemento specificato che non può essere aggiunto a causa della sua classe.
- IllegalArgumentException se l'elemento / argomento aggiunto è illegale o non valido.
Il seguente programma Java mostra una dimostrazione di tutti i metodi ListIterator sopra.
import java.util.*; public class Main{ public static void main(String args()){ //define list and add elements to it ListnameList=new ArrayList(); nameList.add('Savich'); nameList.add('Dane'); nameList.add('Lacey'); nameList.add(1,'James'); System.out.println('Original List:' + nameList); //define a list iterator for this list ListIterator list_itr=nameList.listIterator(); System.out.println('List elements in forward direction:'); //while there are still elements in the list, display next index and element while(list_itr.hasNext()){ System.out.println('Index:'+list_itr.nextIndex()+' Element:'+list_itr.next()); } //call set() method to set next value to 'Sally' list_itr.set('Sally'); System.out.println('
List after set('Sally'):' + nameList); //while there are elements in the list, display previous index and element System.out.println('
List elements in backward direction:'); while(list_itr.hasPrevious()){ System.out.println('Index:'+list_itr.previousIndex()+' Element:'+list_itr.previous()); } //call remove () method list_itr.remove(); System.out.println('List after remove():' + nameList); } } Produzione:
Interfaccia ListIterator negli esempi Java
Vediamo un altro esempio di utilizzo di ListIterator. In questo programma, abbiamo un ArrayList di valori interi. Quindi utilizzando ListIterator attraversiamo l'elenco e visualizziamo gli elementi dell'elenco.
Inoltre, selezioniamo solo elementi pari in ArrayList e cambiamo i loro valori in numeri dispari utilizzando i metodi ListIterator.
import java.util.ArrayList; import java.util.ListIterator; public class Main { public static void main(String() args) { //define ArrayList and add values to it using for loop ArrayList intList = new ArrayList(); for (int i = 0; i <10; i++) intList.add(i+2); System.out.println('Original ArrayList:' + intList); // define the ListIterator ListIterator list_itr = intList.listIterator(); System.out.println('List elements using listIterator:'); //while list has more elements while (list_itr.hasNext()) { //retrieve next element int i = (Integer)list_itr.next(); // print the element System.out.print(i + ' '); // change only even numbers to odd by setting value = value +1 to current element if (i%2==0) { list_itr.set(i+1); // set method to change value } } System.out.println(); System.out.println('Final ArrayList of odd values:' + intList); } }Produzione:
Domande frequenti
D # 1) Cosa si intende per iteratore?
Risposta: Iterator è un'interfaccia che fa parte del framework Collection in Java. Questa interfaccia è presente nel pacchetto java.util. L'interfaccia dell'iteratore viene utilizzata per scorrere la raccolta di oggetti.
D # 2) Cos'è un'interfaccia iteratore in Java?
Risposta: Un'interfaccia iteratore in Java viene utilizzata al posto delle enumerazioni utilizzate in precedenza in Java Collection Framework. L'interfaccia dell'iteratore è presente in Java dalla versione 1.2.
Utilizzando questa interfaccia è possibile scorrere qualsiasi raccolta Java ed elaborare gli elementi della raccolta.
D # 3) Qual è l'uso del metodo listIterator () in Java?
Risposta: Il metodo listIterator () appartiene al pacchetto java.util. *. Questo metodo restituisce un iteratore di elenco per il particolare oggetto elenco che lo ha richiamato e può essere utilizzato per attraversare gli elenchi e accedere agli elementi. ListIterator funziona solo su implementazioni di elenchi.
Esempio di casi di test junit in eclipse
D # 4) L'iteratore è una classe o un'interfaccia?
Risposta: Iterator non è una classe ma un file interfaccia in Java . L'interfaccia di Iterator può essere implementata dalle altre classi e utilizzata per iterare attraverso elementi di elenchi o raccolte.
D # 5) Quanti tipi di iteratori ci sono in Java?
Risposta: Gli iteratori in Java sono di tre tipi:
- Enumerazioni: Questa è un'interfaccia che viene utilizzata per leggere gli elementi da raccolte come Vector, hashtable, ecc. Ogni elemento è numerato in base alla sua posizione nella raccolta.
- Iteratore: Puoi chiamare questa interfaccia universale in quanto puoi applicarla a qualsiasi oggetto della raccolta per attraversare la raccolta. Questa è un'enumerazione migliorata con funzionalità di rimozione insieme alla capacità di leggere un elemento.
- ListIterator: ListIterator è un'interfaccia che fornisce l'iterazione bidirezionale, cioè nelle direzioni avanti e indietro. ListIterator funziona solo con implementazioni di elenchi tra cui LinkedList, ArrayList, ecc.
Conclusione
L'interfaccia ListIterator in Java è derivata dall'interfaccia Iterator. Oltre ad ereditare direttamente i metodi dell'interfaccia Iterator, l'interfaccia listIterator introduce vari metodi propri che possono aiutare il programmatore a eseguire l'iterazione bidirezionale.
In questo tutorial, abbiamo discusso il diagramma delle classi e i vari metodi dell'interfaccia ListIterator. Abbiamo anche visto l'implementazione di questi metodi insieme ai modi per attraversare vari elenchi.
=> Visita qui per vedere la serie di formazione Java per tutti.
Lettura consigliata
- Tutorial sull'interfaccia Java e sulla classe astratta con esempi
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici
- Iteratore Java: impara a utilizzare gli iteratori in Java con esempi
- Tutorial sulla lunghezza di array Java con esempi di codice
- Jagged Array in Java - Tutorial con esempi
- Invertire un array in Java - 3 metodi con esempi
- Come ordinare un array in Java - Tutorial con esempi
- Funzioni di rilievo di Java 8 con esempi di codice