java list methods sort list
Questo tutorial spiega vari metodi di elenchi Java come Elenco di ordinamento, Elenco contiene, Aggiungi elenco, Rimuovi elenco, Dimensione elenco, Aggiungi tutto, Rimuovi tutto, Inverti elenco e altro:
Abbiamo già discusso l'interfaccia della lista in generale nel nostro precedente tutorial. L'interfaccia dell'elenco dispone di vari metodi utilizzati per manipolare il contenuto dell'elenco. Utilizzando questi metodi è possibile inserire / eliminare, ordinare e cercare elementi nell'elenco.
In questo tutorial, discuteremo tutti i metodi forniti dall'interfaccia list.
=> Controlla qui per vedere qui i tutorial di formazione su Java dalla A alla Z.
Per scorrere l'elenco, l'interfaccia di elenco utilizza l'iteratore di elenco. Questo iteratore di elenco si estende dall'interfaccia dell'iteratore. Nel nostro prossimo tutorial, esploreremo di più sull'iteratore della lista.
Cosa imparerai:
- Elenca metodi in Java
- Rimuovi duplicati da un elenco in Java
- Domande frequenti
- Conclusione
- Lettura consigliata
Elenca metodi in Java
La tabella seguente mostra varie funzioni fornite dall'interfaccia elenco in Java.
| Metodo elenco | Metodo Prototipo | Descrizione |
|---|---|---|
| contiene | booleano contiene (Oggetto o) | Controlla se l'elemento specificato è presente nell'elenco e restituisce true se presente |
| taglia | int size () | Restituisce la dimensione dell'elenco, ovvero il numero di elementi nell'elenco o la lunghezza dell'elenco. |
| chiaro | void clear () | Cancella l'elenco rimuovendo tutti gli elementi nell'elenco |
| Inserisci | void add (int index, Object element) | Aggiunge l'elemento dato alla lista all'indice dato |
| booleano add (Object o) | Aggiunge l'elemento dato alla fine dell'elenco | |
| Aggiungi tutto | booleano addAll (Collezione c) | Aggiunge l'intera raccolta data alla fine dell'elenco |
| booleano addAll (int index, Collection c) | Inserisce la raccolta data (tutti gli elementi) nell'elenco in corrispondenza dell'indice specificato | |
| containsAll | booleano containsAll (raccolta c) | Controlla se la raccolta specificata (tutti gli elementi) fa parte dell'elenco. Restituisce vero di sì. |
| è uguale a | booleano è uguale a (Oggetto o) | Confronta l'oggetto specificato per l'uguaglianza con gli elementi dell'elenco |
| Ottenere | Oggetto get (int index) | Restituisce l'elemento nell'elenco specificato da index |
| codice hash | int hashCode () | Restituisce il valore del codice hash di List. |
| indexOf` | int indexOf (Oggetto o) | Trova la prima occorrenza dell'elemento di input e restituisce il suo indice |
| è vuoto | booleano isEmpty () | Controlla se l'elenco è vuoto |
| lastIndexOf | int lastIndexOf (Object o) | Trova l'ultima occorrenza dell'elemento di input nell'elenco e restituisce il suo indice |
| rimuovere | Object remove (int index) | Rimuove l'elemento in corrispondenza dell'indice specificato |
| booleano remove (Object o) | Rimuove l'elemento alla sua prima occorrenza nell'elenco | |
| Rimuovi tutto | booleano removeAll (Collezione c) | Rimuove dall'elenco tutti gli elementi contenuti nella raccolta specificata |
| keepAll | boolean keepAll (Collection c) | Opposto di removeAll. Conserva l'elemento specificato nella raccolta di input nell'elenco. |
| Impostato | Insieme di oggetti (indice int, elemento oggetto) | Modifica l'elemento in corrispondenza dell'indice specificato impostandolo sul valore specificato |
| subList | List subList (int fromIndex, int toIndex) | Restituisce un sottoelenco di elementi tra fromIndex (incluso) e toIndex (esclusivo). |
| ordinare | void sort (comparatore c) | Ordina l'elemento dell'elenco secondo il comparatore specificato per fornire un elenco ordinato |
| toArray | Object () toArray () | Restituisce la rappresentazione in matrice dell'elenco |
| Object () toArray (Object () a) | Restituisce la rappresentazione della matrice il cui tipo di runtime è uguale a un argomento della matrice specificato | |
| iteratore | Iteratore iteratore () | Restituisce un iteratore per l'elenco |
| listIterator | ListIterator listIterator () | Restituisce un ListIterator per l'elenco |
| ListIterator listIterator (int index) | Restituisce un ListIterator a partire dall'indice specificato nell'elenco |
Successivamente, discuteremo queste funzioni insieme ai loro esempi.
taglia
Prototipo: int size ()
Parametri: NIL
Valore di ritorno: int => Numero di elementi nella lista o in altre parole la lunghezza della lista.
Descrizione: La dimensione () restituisce il numero di elementi o la dimensione dell'elenco. Può anche essere chiamato lunghezza in termini semplici.
chiaro
Prototipo: void clear ()
Parametri: NIL
Valore di ritorno: Nessun valore restituito
Descrizione: Cancella l'elenco rimuovendo tutti gli elementi dell'elenco. Genera 'UnSupportedException' se l'operazione non è supportata dall'elenco.
L'esempio seguente mostrerà il metodo size () e clear ().
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list //add items to list strList.add('Java'); strList.add('C++'); //print the size of list System.out.println('Size of list:' + strList.size()); //add more items to list strList.add('Ruby'); strList.add('Python'); strList.add('C#'); //print the size of list again System.out.println('Size of list after adding more elements:' + strList.size()); //clear method strList.clear(); System.out.println('List after calling clear() method:' + strList); } } Produzione:
Inserisci
Prototipo: void add (int index, Object element)
strumento di riparazione del software di Windows Windows 10
Parametri: index- una posizione in cui l'elemento deve essere aggiunto.
Elemento: l'elemento da aggiungere
Valore di ritorno: vuoto
Descrizione: Aggiunge l'elemento dato alla lista all'indice dato. Gli elementi successivi vengono spostati a destra.
Vengono generate le seguenti eccezioni:
IndexOutOfBoundsException: L'indice dell'elenco è fuori intervallo
UnsupportedOperationException: L'operazione di aggiunta non è supportata dall'elenco.
ClassCastException: L'elemento non può essere aggiunto all'elenco a causa della classe di elementi specificati.
IllegalArgumentException: L'elemento specificato o qualche aspetto non è corretto.
Inserisci
Prototipo: booleano add (Object o)
Parametri: o => Elemento da aggiungere alla lista
Valore di ritorno: true => Elemento aggiunto con successo
False => Aggiunta non riuscita
Descrizione: Questo metodo aggiunge l'elemento dato alla fine dell'elenco.
Questa operazione può generare le seguenti eccezioni.
UnsupportedOperationException: Aggiungi operazione non supportata da questo elenco.
ClassCastException: L'elemento specificato non può essere aggiunto a causa della sua classe
IllegalArgumentException: L'elemento specificato o qualche aspetto non è corretto.
Aggiungi tutto
Prototipo: booleano addAll (Collezione c)
Parametri: c => Collezione i cui elementi devono essere aggiunti alla lista
Valore di ritorno: true => Esecuzione del metodo riuscita
Descrizione: Il metodo addAll prende tutti gli elementi dalla raccolta ce li aggiunge alla fine dell'elenco mantenendo l'ordine impostato.
Questo metodo presenta un comportamento non specificato se la raccolta viene modificata durante l'operazione.
Il metodo genera le seguenti eccezioni:
UnsupportedOperationException: Aggiungi operazione non supportata da questo elenco.
ClassCastException: L'elemento specificato non può essere aggiunto a causa della sua classe.
IllegalArgumentException: L'elemento specificato o qualche aspetto non è corretto.
Aggiungi tutto
Prototipo: booleano addAll (int index, Collection c)
Parametri: index => Posizione in cui deve essere inserita la raccolta.
C => Collezione da inserire nella lista.
Valore di ritorno: true => Se gli elementi della raccolta vengono aggiunti con successo all'elenco.
Descrizione: Il metodo addAll inserisce tutti gli elementi nella raccolta specificata nell'elenco in corrispondenza dell'indice specificato. Gli elementi successivi vengono quindi spostati a destra. Come nel caso del precedente overload di addAll, il comportamento non è specificato se la raccolta viene alterata durante l'operazione.
Le eccezioni generate da questo metodo sono:
UnsupportedOperationException: Aggiungi operazione non supportata da questo elenco.
ClassCastException: L'elemento specificato non può essere aggiunto a causa della sua classe.
IllegalArgumentException: L'elemento specificato o qualche aspetto non è corretto.
IndexOutOfBoundsException: Indice fuori intervallo.
Il programma seguente mostra la dimostrazione dei metodi add e addAll dell'elenco.
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list strList.add('Java'); strList.add('C++'); //print the list System.out.println('List after adding two elements:' + strList); List llist = new ArrayList(); // Create another list llist.add('Ruby'); llist.add('Python'); llist.add('C#'); // addAll method - add llist to strList strList.addAll(llist); System.out.println('List after addAll:'+ strList); } } Produzione:
contiene
Prototipo: booleano contiene (Oggetto o)
Parametri: o => Elemento da ricercare nell'elenco.
Valore di ritorno: true => Se la lista contiene l'elemento specificato.
Descrizione: Il metodo 'contiene' controlla se l'elemento specificato è presente nell'elenco e restituisce un valore booleano true se l'elemento è presente. In caso contrario, restituisce false.
containsAll
Prototipo: booleano containsAll (raccolta c)
Parametri: c => Collezione da cercare nell'elenco.
Valore di ritorno: true => Se tutti gli elementi nella raccolta specificata sono presenti nell'elenco.
Descrizione: Il metodo 'containsAll' controlla se tutti gli elementi presenti nella raccolta specificata sono presenti nell'elenco. Se presente restituisce un valore vero e falso altrimenti.
Il seguente programma Java dimostra l'utilizzo dei metodi 'contains' e 'containsAll' dell'elenco.
import java.util.*; public class Main { public static void main(String() args) { //define list of strings List list = new ArrayList(); //initialize list to strings list.add('Java'); list.add('Xml'); list.add('Python'); list.add('Ruby'); list.add('JavaScript'); //contains method demo if(list.contains('C')==true) System.out.println('Given list contains string 'C''); else if(list.contains('Java')==true) System.out.println('Given list contains string 'Java' but not string 'C''); //containsAll method demo List myList = new ArrayList(); myList.add('Ruby'); myList.add('Python'); if(list.containsAll(myList)==true) System.out.println('List contains strings 'Ruby' and 'Python''); } }Produzione:
L'elenco fornito contiene la stringa 'Java' ma non la stringa 'C'
L'elenco contiene le stringhe 'Ruby' e 'Python'
è uguale a
Prototipo: booleano è uguale a (Oggetto o)
Parametri: o => L'oggetto che deve essere testato per l'uguaglianza.
Valore di ritorno: true => Se l'oggetto dato è uguale alla lista.
Descrizione: Questo metodo viene utilizzato per confrontare l'oggetto dato con l'elenco di uguaglianza. Se l'oggetto specificato è un elenco, il metodo restituisce true. Si dice che entrambe le liste sono uguali se e solo se hanno la stessa dimensione e gli elementi corrispondenti nelle due liste sono uguali e nello stesso ordine.
Di seguito viene fornita una dimostrazione del metodo uguale:
import java.util.LinkedList; import java.util.List; public class Main { public static void main(String() args) { //define lists List first_list= new LinkedList(); List second_list = new LinkedList(); List third_list = new LinkedList(); //initialize lists with values for (int i=0;i<11;i++){ first_list.add(i); second_list.add(i); third_list.add(i*i); } //print each list System.out.println('First list: ' + first_list); System.out.println('Second list: ' + second_list); System.out.println('Third list: ' + third_list); //use equals method to check equality with each list to other if (first_list.equals(second_list) == true) System.out.println('
first_list and second_list are equal.
'); else System.out.println('first_list and second_list are not equal.
'); if(first_list.equals(third_list)) System.out.println('first_list and third_list are equal.
'); else System.out.println('first_list and third_list are not equal.
'); if(second_list.equals(third_list)) System.out.println('second_list and third_list are equal.
'); else System.out.println('second_list and third_list are not equal.
'); } } Produzione:
Ottenere
Prototipo: Oggetto get (int index)
Parametri: index => Posizione in cui deve essere restituito l'elemento.
Valore di ritorno: oggetto => Elemento nella posizione specificata.
Descrizione: Il metodo get () restituisce l'elemento nella posizione data.
Questo metodo genera 'indexOutOfBoundsException' se l'indice specificato non è compreso nell'intervallo dell'elenco.
Impostato
Prototipo: Insieme di oggetti (indice int, elemento oggetto)
Parametri: index => Posizione in cui deve essere impostato il nuovo elemento.
element => Nuovo elemento da posizionare nella posizione data da index.
Valore di ritorno: Object => Elemento che è stato sostituito
Descrizione: Il metodo set () sostituisce l'elemento all'indice dato con un altro valore dato da element.
Il metodo può generare le seguenti eccezioni:
UnsupportedOperationException: L'operazione di impostazione non è supportata dall'elenco.
ClassCastException: Impossibile eseguire l'operazione a causa della classe dell'elemento
IllegalArgumentException: La discussione o qualche aspetto di essa è illegale
IndexOutOfBoundsException: Indice fuori intervallo.
Il seguente programma mostra un esempio del metodo get () e set ().
import java.util.*; public class Main { public static void main(String() args) { //define list List listA = new ArrayList(); listA.add('Java'); listA.add('C++'); listA.add('Python'); //access list elements using index with get () method System.out.println('Element at index 0:' + listA.get(0)); System.out.println('Element at index 1:' + listA.get(1)); System.out.println('Element at index 2:' + listA.get(2)); //set element at index 1 to Ruby listA.set(1,'Ruby'); System.out.println('Element at index 1 changed to :' + listA.get(1) ); } } Produzione:
codice hash
Prototipo: int hashCode ()
Parametri: NIL
Valore di ritorno: int => hashCode della lista
Descrizione: Il metodo 'hashCode ()' restituisce l'hashCode della lista che è un valore intero.
Esempio:
import java.util.*; public class Main { public static void main(String() args) { // Initializing a list of type Linkedlist List mylist = new LinkedList(); mylist.add(1); mylist.add(3); mylist.add(5); mylist.add(7); //print the list System.out.println('The list:' + mylist); //use hashCode() method to find hashcode of list int hash = mylist.hashCode(); System.out.println('Hashcode for list:' + hash); } } Produzione:
è vuoto
Prototipo: booleano isEmpty ()
Parametri: NIL
Valore di ritorno: true => L'elenco è vuoto
Descrizione: Il metodo 'isEmpty ()' controlla se l'elenco è vuoto. Il metodo IsEmpty viene utilizzato per verificare se l'elenco contiene elementi prima di iniziare a elaborarli.
indice di
Prototipo: int indexOf (Oggetto o)
Parametri: o => elemento da cercare nell'elenco
Valore di ritorno: int => l'indice o la posizione della prima occorrenza di un dato elemento nell'elenco. Restituisce -1 se l'elemento non è presente.
Descrizione: Il metodo 'indexOf ()' restituisce l'indice della prima occorrenza del dato elemento o nell'elenco. Se l'elemento non viene trovato, restituisce -1.
lastIndexOf
Prototipo: int lastIndexOf (Object o)
Parametri: o => Oggetto il cui indice deve essere cercato
Valore di ritorno: int => Indice dell'ultima occorrenza dell'elemento specificato nell'elenco, -1 altrimenti.
Descrizione: Il metodo 'lastIndexOf ()' restituisce l'indice dell'ultima occorrenza dell'elemento o nell'elenco. Se l'elemento non viene trovato, il metodo restituisce -1.
Il seguente programma Java mostra l'utilizzo dei metodi indexOf e lastIndexOf dell'elenco.
import java.util.*; public class Main { public static void main(String() args) { // define an integer array List intList = new ArrayList(5); //add elements to the list intList.add(10); intList.add(20); intList.add(30); intList.add(10); intList.add(20); //print the list System.out.println('The list of integers:' + intList); // Use indexOf() and lastIndexOf() methods of list to find first and last index System.out.println('first index of 20:' + intList.indexOf(20)); System.out.println('last index of 10:' + intList.lastIndexOf(10)); } } Produzione:
rimuovere
Prototipo: Object remove (int index)
Parametri: index => Indice o posizione nell'elenco in cui l'elemento deve essere rimosso
Valore di ritorno: Oggetto => Elemento rimosso
Descrizione: Il metodo 'remove ()' rimuove l'elemento nella posizione specificata dall'elenco. Dopo l'eliminazione, gli elementi accanto all'elemento eliminato vengono spostati a sinistra.
Questo metodo può generare le seguenti eccezioni:
UnsupportedOperationException: La rimozione non è supportata dall'elenco.
IndexOutOfBoundsException: L'indice specificato è fuori intervallo
rimuovere
Prototipo: booleano remove (Object o)
Parametri: o => Elemento da rimuovere dalla lista
Valore di ritorno: true => L'elemento è stato rimosso con successo.
Descrizione: Questa versione sovraccaricata del metodo remove () rimuove la prima occorrenza di un dato elemento o dall'elenco. Se l'elemento dato non è presente nell'elenco, rimane invariato.
Questo metodo può generare la seguente eccezione:
UnsupportedOperationException: La rimozione non è supportata dall'elenco.
Rimuovi tutto
Prototipo: booleano removeAll (Collezione c)
Parametri: c => Una raccolta che contiene elementi rimossi dall'elenco.
Valore di ritorno: true => Se la chiamata al metodo ha esito positivo e tutti gli elementi specificati nella raccolta c vengono rimossi dall'elenco.
Descrizione: Il metodo 'removeAll ()' viene utilizzato per rimuovere tutti gli elementi dall'elenco che sono specificati nella raccolta c che viene passata come argomento.
Questo metodo può generare la seguente eccezione:
UnsupportedOperationException: removeAll non è supportato dall'elenco.
Vediamo un esempio dei metodi remove e removeAll.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); // Removes element from index 1 oddList.remove(1); System.out.println('Oddlist after removing element at index 1:' + oddList); //removeAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.removeAll(c1); System.out.println('Oddlist after removing elements {1,5,11}}:' + oddList); } } Produzione:
keepAll
Prototipo: boolean keepAll (Collection c)
Parametri: c => Collection che contiene elementi che dovrebbero essere mantenuti nell'elenco.
Valore di ritorno: true => Se la chiamata al metodo ha modificato l'elenco.
Descrizione: Questo metodo rimuove tutti gli elementi dalla lista ad eccezione di quelli presenti nella collezione c. In altre parole, questo metodo conserva tutti gli elementi nell'elenco che sono presenti nella raccolta c e rimuove gli altri elementi.
Questo metodo può generare la seguente eccezione:
UnsupportedOperationException: keepAll non è supportato da List.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); //retainAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.retainAll(c1); System.out.println('Oddlist after call to retainAll (1,5,11):' + oddList); } } Produzione:
subList
Prototipo: List subList (int fromIndex, int toIndex)
Parametri: fromIndex => Indice inferiore della lista (compreso)
toIndex => Indice superiore della lista (esclusivo)
Valore di ritorno: List => Una sottoelenco della lista data
Descrizione: Il metodo sublist () restituisce la vista parziale dell'elenco, noto anche come sottolista da 'fromIndex' a 'toIndex'. Il sottoelenco restituito è solo una visualizzazione dell'elenco padre e quindi qualsiasi modifica apportata a uno degli elenchi si riflette ovunque.
Allo stesso modo, tutte le operazioni della lista funzionano anche su una sottolista.
Il metodo può generare la seguente eccezione:
IndexOutOfBoundsException: Valore toIndex illegale.
Di seguito viene fornito un programma di esempio per il metodo delle sottoliste.
import java.util.*; public class Main { public static void main(String() args) { // define a string list List strList = new ArrayList(5); //add elements to the list strList.add('Java'); strList.add('Tutorials'); strList.add('Collection'); strList.add('Framework'); strList.add('Series'); //print the original list System.out.println('The original list=>strList: ' + strList); //define another list List subList = new ArrayList(); // take a sublist of elements from 2 to 4 from strList subList = strList.subList(2, 4); //print the sublist System.out.println('The sublist of strList:' + subList); } } Produzione:
elenco di ordinamento
Prototipo: void sort (comparatore c)
Parametri: c => Comparatore in base al quale viene ordinato l'elenco.
Valore di ritorno: NIL
Descrizione: Il metodo 'sort ()' viene utilizzato per ordinare l'elenco. Il metodo utilizza il comparatore specificato per ordinare l'elenco.
Vediamo un esempio del metodo di ordinamento . Lo abbiamo confrontato con il metodo Collections.sort che ordina gli elementi in una sequenza naturale. L'output del programma è un elenco ordinato.
import java.util.Collections; import java.util.ArrayList; import java.util.List; import java.util.Random; public class Main { public static void main(String() args) { //define list List intArray = new ArrayList(); Random random = new Random(); //populate the list with random numbers <20 for (int i = 0; i {return (o2-o1);}); //comparator to sort in reverse System.out.println('Reverse List sorted using comparator:
'+intArray); } }Produzione:
toArray
Prototipo: Object () toArray ()
Parametri: NIL
Valore di ritorno: Object () => Rappresentazione array della lista
Descrizione: Il metodo toArray () restituisce la rappresentazione in matrice dell'elenco in una sequenza corretta.
toArray
Prototipo: Object () toArray (Object () a)
Parametri: a => Tipo di array che deve essere abbinato ai tipi di elementi dell'elenco durante la conversione dell'elenco in un array.
Valore di ritorno: Object () => Rappresentazione array della lista.
Descrizione: Questo overload del metodo toArray () restituisce l'array contenente gli elementi nell'elenco che hanno lo stesso tipo di runtime di quello dell'array a.
Questo metodo può generare la seguente eccezione:
ArrayStoreException: Il tipo di runtime di ogni elemento nell'elenco non è un sottotipo del tipo di runtime di ogni elemento in questo elenco.
Quello che segue è un esempio dell'implementazione del metodo toArray.
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('Size of the colorsList: ' + colorsList.size()); // Print the colors in the list System.out.println('Contents of colorsList:'); for (String value : colorsList){ System.out.print(value + ' '); } // Create an array from the list using toArray method String colorsArray() = new String(colorsList.size()); colorsArray = colorsList.toArray(colorsArray); // Display the contents of the array System.out.println('
Printing elements of colorsArray:' + Arrays.toString(colorsArray)); } }Produzione:
Iteratore
Prototipo: Iteratore iteratore ()
Parametri: NIL
Valore di ritorno: Iteratore => Iteratore per scorrere gli elementi della lista
Descrizione: Questo metodo restituisce l'iteratore che esegue l'iterazione sugli elementi nell'elenco.
Programma Java per dimostrare l'utilizzo dell'iteratore.
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('ColorList using iterator:'); //define iterator for colorsList Iterator iterator = colorsList.iterator(); //iterate through colorsList using iterator and print each item while(iterator.hasNext()){ System.out.print(iterator.next() + ' '); } } } Produzione:
listIterator
Prototipo: ListIterator listIterator ()
Parametri: NIL
Valore di ritorno: ListIterator => Listiterator degli elementi nella lista.
Descrizione: Il metodo listIterator () restituisce l'oggetto ListIterator degli elementi nell'elenco. Questo iteratore parte dall'inizio dell'elenco, ovvero l'indice 0.
listIterator
Prototipo: ListIterator listIterator (int index)
Parametri: index => Posizione in cui inizia listIterator.
Valore di ritorno: ListIterator => Oggetto ListIterator all'indice specificato nell'elenco.
Descrizione: L'overload del metodo listIterator () restituisce un listIterator che inizia nella posizione specificata nell'elenco. L'indice fornito indica che sarà il primo elemento che verrà restituito dalla prima chiamata al metodo nextElement () di ListIterator.
Il metodo può generare IndexOutOfBoundsException per il valore non valido dell'indice.
L'esempio seguente mostra l'utilizzo di listIterator.
import java.util.*; public class Main { public static void main(String() args) { //define list & add items to list List nameList = new LinkedList(); nameList.add('Java'); nameList.add('C++'); nameList.add('Python'); // get listIterator for the list ListIterator namesIterator = nameList.listIterator(); // Traverse list using listiterator and print each item System.out.println('Contents of list using listIterator:'); while(namesIterator.hasNext()){ System.out.print(namesIterator.next() + ' '); } } } Produzione:
Discuteremo ListIterator in dettaglio più avanti.
Esaminiamo ora alcune delle operazioni varie che possono essere eseguite sugli elenchi, ma metodi per i quali non sono forniti nell'interfaccia dell'elenco.
Copia elenco in Java
Per copiare gli elementi di una lista in un'altra lista, devi usare il metodo copy () fornito dal framework delle collezioni.
Il metodo Collections.copy () copia tutti gli elementi della lista fornita come secondo argomento, nella lista fornita come primo argomento. Notare che l'elenco in cui vengono copiati i contenuti di un altro elenco dovrebbe essere sufficientemente grande da contenere gli elementi copiati.
Se l'elenco non è abbastanza grande, il metodo di copia genera 'indexOutOfBoundsEexception'.
Il seguente programma copia il contenuto di un elenco in un altro.
import java.util.*; public class Main { public static void main(String() args) { //create first ArrayList object List aList_1 = new ArrayList(); //Add elements to first ArrayList aList_1.add('R'); aList_1.add('G'); aList_1.add('B'); //print the List System.out.println('The first list:' + aList_1); //create second ArrayList object List aList_2 = new ArrayList(); //Add elements to second Arraylist aList_2.add('Red'); aList_2.add('Green'); aList_2.add('Blue'); aList_2.add('Yellow'); aList_2.add('Brown'); System.out.println('The second list: ' + aList_2); //use Collections.copy() method to copy elements of first list to second list. Collections.copy(aList_2,aList_1); //print the resultant second Arraylist System.out.println('
The second list after copying first list to second list: ' + aList_2); } } Produzione:
Rimuovi duplicati da un elenco in Java
Un dato elenco può contenere o meno elementi ripetitivi o duplicati. Se l'elenco con cui stai lavorando contiene elementi duplicati e desideri tutti gli elementi distinti nell'elenco, esistono due metodi per rimuovere i duplicati dall'elenco supportato in Java.
Utilizzando Java 8 stream
Il primo metodo per rimuovere i duplicati dall'elenco è utilizzare il metodo separate () fornito da Java 8 stream. Qui, l'elenco contenente i duplicati richiama il metodo stream () .distinct e quindi il valore restituito viene convertito in un nuovo elenco che avrà solo gli elementi distinti.
Il seguente programma dimostra l'utilizzo del metodo separate ().
import java.util.*; import java.util.stream.Collectors; class Main { public static void main(String() args) { // original list List intlist = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5,6,5,3,4)); // Print the list System.out.println('Original ArrayList: ' + intlist); // using distinct() method of Java 8 stream remove duplicates from original List //and generate a new list without duplicates List distinct_list = intlist.stream().distinct() .collect(Collectors.toList()); // Print the new list System.out.println('ArrayList after removing duplicates: ' + distinct_list); } } Produzione:
Utilizzando l'approccio Iterator
Rimuovere i duplicati dall'elenco utilizzando l'iteratore è un approccio lungo e primitivo. In questo approccio, devi attraversare l'elenco e inserire la prima occorrenza di ogni elemento in un nuovo elenco. Ogni elemento successivo viene controllato se è un duplicato.
Il programma seguente consente di ottenere questo risultato.
software per scaricare video da qualsiasi sito
import java.util.*; public class Main { public static void main(String args()) { // create original list ArrayList aList = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 5, 3, 4)); // Print the original list System.out.println('Original List: '+ aList); // Create a new list ArrayList new_List = new ArrayList(); // Traverse through the original list to remove duplicates for (Integer element : aList) { // check if element is present in new_List, else add it if (!new_List.contains(element)) { new_List.add(element); } } // Print the new list without duplicates System.out.println('List after removing duplicates: '+ new_List); } } Produzione:
Domande frequenti
D # 1) Cos'è il metodo get nell'elenco in Java?
Risposta: Il metodo Get dell'elenco viene utilizzato per recuperare un particolare elemento nell'elenco in base all'indice. Si passa l'indice richiesto al metodo get e il metodo get restituirà il valore dell'elemento in quell'indice.
D # 2) Qual è il metodo toArray in Java?
Risposta: Il metodo toArray () viene utilizzato per ottenere la rappresentazione dell'array dell'elenco.
D # 3) Come si ordina un elenco in Java?
Risposta: In Java, un elenco può essere ordinato utilizzando il metodo di ordinamento dell'elenco. È possibile passare i propri criteri di ordinamento utilizzando l'interfaccia di confronto che viene passata al metodo di ordinamento come parametro.
Puoi anche utilizzare le raccolte. Metodo di ordinamento per ordinare l'elenco. Questo metodo ordina l'elenco secondo l'ordine naturale.
Q # 4) Cos'è Arrays.asList () in Java?
Risposta: Il metodo 'asList' di array restituisce l'elenco di elementi supportati da un array.
Conclusione
In questo tutorial, abbiamo imparato tutti i metodi forniti da un elenco. L'elenco Java fornisce vari metodi con i quali è possibile manipolare ed elaborare elenchi, inclusi ricerca, ordinamento, ecc. Abbiamo spiegato ogni metodo con esempi di programmazione appropriati qui.
Nel nostro prossimo tutorial, discuteremo in dettaglio ListIterator.
=> Esplora la serie di formazione Java semplice qui.
Lettura consigliata
- Elenco Java - Come creare, inizializzare e utilizzare l'elenco in Java
- Elenco nascosto per array e altre raccolte in Java
- Python Advanced List Tutorial (List Sort, Reverse, Index, Copy, Join, Sum)
- Elenco Python: crea, accedi, seziona, aggiungi o elimina elementi
- Thread Java con metodi e ciclo di vita
- Rimuovi / Elimina un elemento da un array in Java
- Tutorial Java String | Metodi Java String con esempi
- Elenco degli indirizzi IP del router predefinito per le marche comuni di router wireless