arraylist methods java tutorial with example programs
In questo tutorial, discuteremo i metodi Java ArrayList come add, addAll, remove, removeAll, size, contains, keepAll, Sort, Reverse, ecc. Con Esempi:
Nel tutorial precedente, abbiamo esplorato la struttura dati ArrayList e la classe ArrayList fornita per questa struttura / raccolta dati in Java. Abbiamo imparato la creazione, l'inizializzazione, ecc. Degli oggetti ArrayList.
Oltre a queste funzionalità che ci aiutano a definire ArrayList, la classe ArrayList in Java fornisce anche un'API di funzione completa che consiste in metodi utilizzati per manipolare oggetti ArrayList.
=> Controlla TUTTI i tutorial Java qui.
Questi metodi ci consentono di aggiungere, eliminare, cercare elementi in ArrayList, nonché di recuperare la lunghezza / dimensione degli elementi ArrayList, ecc.
In questo tutorial, discuteremo questi metodi in dettaglio con semplici esempi di programmazione.
Cosa imparerai:
- Metodi ArrayList in Java
- ArrayList aggiungi
- ArrayList addAll
- ArrayList Aggiungi in primo piano
- ArrayList rimuovere
- ArrayList removeAll
- ArrayList removeRange
- ArrayList size (Lunghezza)
- ArrayList contiene
- ArrayList get
- ArrayList set (Sostituisci elemento)
- ArrayList clear
- ArrayList isEmpty
- ArrayList indexOf
- ArrayList lastIndexOf
- ArrayList toArray
- Clone di ArrayList
- ArrayList subList
- ArrayList keepAll
- ArrayList Iterator
- ArrayList listIterator
- Aggiungi array a ArrayList in Java
- Ordina ArrayList in Java
- Invertire un ArrayList in Java
- Rimuovi i duplicati da un ArrayList in Java
- Shuffle (Randomize) An ArrayList in Java
- Domande frequenti
- Conclusione
Metodi ArrayList in Java
La tabella seguente elenca tutti i metodi forniti dalla classe ArrayList.
Metodo | Metodo Prototipo | Descrizione del metodo |
---|---|---|
Contiene | booleano contiene (Oggetto o) | Controlla se l'elenco contiene l'elemento specificato 'o'. Restituisce vero se l'elemento è presente. |
Inserisci | booleano add (E e) | Aggiunge un dato elemento e alla fine della lista. |
void add (int index, E element) | Aggiunge un dato elemento 'elemento' nella posizione specificata 'indice'. | |
Aggiungi tutto | booleano addAll (Collezione c) | Aggiunge tutti gli elementi nella raccolta data c alla fine dell'elenco. |
booleano addAll (int index, Collection c) | Aggiunge tutti gli elementi nella raccolta data c nella posizione specificata da 'indice' nell'elenco. | |
Chiaro | void clear () | Cancella l'elenco rimuovendo tutti gli elementi dall'elenco. |
Clone | Oggetto clone () | Crea una copia superficiale del dato ArrayList. |
garantire la capacità | voiduranceCapacity (int minCapacity) | Aumenta la capacità di ArrayList per garantire che abbia minCapacity. |
Ottenere | E get (int indice) | Restituisce l'elemento nell'elenco presente nella posizione specificata da 'index'. |
indice di | int indexOf (Oggetto o) | Restituisce l'indice della prima occorrenza dell'elemento o nell'elenco. -1 se l'elemento o non è presente nell'elenco. |
è vuoto | booleano isEmpty () | Controlla se l'elenco fornito è vuoto. |
Iteratore | Iteratore iteratore () | Restituisce un iteratore per attraversare gli elementi della lista nella sequenza corretta. |
lastIndexOf | int lastIndexOf (Object o) | Restituisce l'indice dell'ultima occorrenza dell'elemento specificato o nell'elenco. -1 se l'elemento non è presente nell'elenco. |
listIterator | ListIterator listIterator () | Restituisce l'iteratore della lista per attraversare gli elementi della lista data. |
ListIterator listIterator (int index) | Restituisce l'iteratore della lista a partire dalla posizione specificata 'index' per attraversare gli elementi della lista data. | |
rimuovere | E rimuovi (indice int) | Elimina l'elemento in 'index' in ArrayList. |
booleano remove (Object o) | Elimina la prima occorrenza dell'elemento o dall'elenco. | |
Rimuovi tutto | booleano removeAll (Collezione c) | Rimuove tutti gli elementi dall'elenco che corrispondono agli elementi nella raccolta data c. |
removeRange | protected void removeRange (int fromIndex, int toIndex) | Rimuove gli elementi specificati nell'intervallo dato, daIndex (incluso) a toIndex (esclusivo) dall'elenco. |
keepAll | boolean keepAll (Collection c) | Mantiene gli elementi nell'elenco che corrispondono agli elementi nella raccolta data c. |
impostato | E set (int index, E element) | Imposta il valore dell'elemento in un dato 'indice' al nuovo valore dato da 'elemento'. |
taglia | int size () | Restituisce il numero totale di elementi o la lunghezza dell'elenco. |
subList | List subList (int fromIndex, int toIndex) | Restituisce una subList tra un dato intervallo, daIndex a toIndex per la data lista. |
toArray | Object () toArray () | Converte l'elenco fornito in un array. |
T () toArray (T () a) | Converte l'elenco fornito in un array del tipo fornito da a. | |
trimToSize | void trimToSize () | Riduce la capacità di ArrayList alla dimensione o al numero di elementi presenti nell'elenco. |
Successivamente, discuteremo ciascuno di questi metodi dall'API della funzione ArrayList in dettaglio e presenteremo esempi di programmazione. Dopo aver discusso tutti i metodi sopra elencati, riprenderemo anche alcune operazioni specifiche che vengono eseguite utilizzando ArrayList che non fanno parte dell'API della funzione ArrayList.
ArrayList aggiungi
io
Prototipo: booleano add (E e)
Parametri: e => Elemento da aggiungere all'ArrayList.
Valore di ritorno: true => Elemento aggiunto con successo.
Descrizione: Aggiunge l'elemento e dato alla fine della lista.
II.
Prototipo: void add (int index, E element)
Parametri:
index => Posizione in cui deve essere aggiunto l'elemento.
Element => Elemento da aggiungere a ArrayList.
Valore di ritorno: vuoto
Descrizione: Aggiunge un dato elemento 'elemento' nella posizione specificata 'indice' spostando l'elemento in quella posizione e gli elementi successivi a destra.
Eccezioni: IndexOutOfBoundsException => Se l'indice specificato è fuori dall'intervallo.
ArrayList addAll
io
Prototipo: booleano addAll (Collezione c)
Parametri: c => Collection i cui elementi devono essere aggiunti all'ArrayList.
Valore di ritorno: true => Se l'operazione ha alterato ArrayList.
Descrizione: Aggiunge tutti gli elementi nella raccolta data c alla fine dell'elenco. Il risultato dell'operazione non è definito se la raccolta viene modificata quando l'operazione è in corso.
Eccezioni: NullPointerException => Se la raccolta c data è null.
yl
Prototipo: booleano addAll (int index, Collection c)
Parametri: index => Posizione in cui devono essere aggiunti gli elementi nella raccolta data.
Valore di ritorno: true => Se l'elenco è cambiato a seguito dell'operazione.
Descrizione: Aggiunge tutti gli elementi nella raccolta data c nella posizione specificata da 'indice' nell'elenco. L'elemento all'indice specificato e gli elementi successivi vengono spostati a destra. Il risultato dell'operazione non è definito se la raccolta da aggiungere viene modificata quando l'operazione è in corso.
Eccezioni: IndexOutOfBoundsException: se l'indice a cui aggiungere la raccolta è fuori limite
NullPointerException: se la raccolta c data è null.
Il seguente programma Java dimostra l'utilizzo dei metodi add e addAll.
import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(); //add elements to the ArrayList using add method city_List.add('Delhi'); city_List.add('Mumbai'); city_List.add('Chennai'); city_List.add('Kolkata'); //print the list System.out.println('Initial ArrayList:' + city_List); //add an element at index 1 using add method overload city_List.add(1, 'NYC'); //print the list System.out.println('
rrayList after adding element at index 1:' + city_List); //define a second list ArrayList more_Cities = new ArrayList(Arrays.asList('Pune', 'Hyderabad')); //use addAll method to add the list to ArrayList at index 4 city_List.addAll(4,more_Cities); //print the list System.out.println('
ArrayList after adding list at index 4:' + city_List); } }
Produzione:
Elenco array iniziale: (Delhi, Mumbai, Chennai, Kolkata)
rrayList dopo l'aggiunta di un elemento all'indice 1: (Delhi, NYC, Mumbai, Chennai, Kolkata)
ArrayList dopo aver aggiunto l'elenco all'indice 4: (Delhi, New York, Mumbai, Chennai, Pune, Hyderabad, Kolkata)
Il programma precedente utilizza entrambe le versioni del metodo add per aggiungere elementi all'elenco. Inoltre aggiunge una raccolta all'elenco all'indice specificato. Notare lo spostamento di elementi a destra di ArrayList come evidente dall'output del programma.
ArrayList Aggiungi in primo piano
Come già accennato, la prima versione del metodo add aggiunge gli elementi alla fine della lista. Se vuoi aggiungere gli elementi all'inizio di ArrayList, devi usare la seconda versione del metodo add. Questo metodo di aggiunta accetta un indice come parametro. Questo indice è la posizione in cui l'elemento deve essere aggiunto.
Quindi per aggiungere l'elemento all'inizio della lista, devi specificare l'indice come 0 che è l'inizio della lista.
Il seguente programma aggiunge un elemento all'inizio di ArrayList.
import java.util.ArrayList; public class Main { public static void main(String() args) { //define new ArrayList and initialize it ArrayList numList = new ArrayList(); numList.add(5); numList.add(7); numList.add(9); //print the ArrayList System.out.println('Initial ArrayList:'); System.out.println(numList); //use add method with index=0 to add elements to the beginning of the list numList.add(0, 3); numList.add(0, 1); System.out.println('ArrayList after adding elements at the beginning:'); //print ArrayList System.out.println(numList); } }
Produzione:
Elenco array iniziale:
(5, 7, 9)
ArrayList dopo aver aggiunto elementi all'inizio:
(1, 3, 5, 7, 9)
ArrayList rimuovere
IO.
Prototipo: E rimuovi (indice int)
Parametri: index => Posizione in cui l'elemento deve essere rimosso da ArrayList.
Valore di ritorno: E => Elemento che viene cancellato
Descrizione: Elimina l'elemento in 'index' nell'ArrayList e sposta gli elementi successivi a sinistra.
Eccezioni: IndexOutOfBoundsException => L'indice specificato è fuori intervallo.
II.
Prototipo: booleano remove (Object o)
Parametri: o => Elemento che deve essere rimosso da ArrayList.
Valore di ritorno: true => Se l'elemento è presente nell'elenco.
Descrizione: Elimina la prima occorrenza dell'elemento o dall'elenco. Se l'elemento non è presente nell'elenco, non vi è alcun effetto di questa operazione. Una volta eliminato l'elemento, gli elementi successivi vengono spostati a sinistra.
ArrayList removeAll
Prototipo: booleano removeAll (Collezione c)
Parametri: c => Collection i cui elementi corrispondono a quelli di ArrayList e devono essere rimossi.
Valore di ritorno: true => Se ArrayList viene alterato dall'operazione.
Descrizione: Rimuove tutti gli elementi dall'elenco che corrispondono agli elementi nella raccolta data c. Di conseguenza, gli elementi rimanenti vengono spostati a sinistra dell'elenco.
Eccezioni: ClassCastException => La classe non è la stessa di quella della raccolta specificata, il che implica che la classe è incompatibile.
NullPointerException => Se la raccolta c data è null; o se c ha un elemento nullo e non è consentito dalla raccolta.
ArrayList removeRange
Prototipo: protected void removeRange (int fromIndex, int toIndex)
Parametri: fromIndex => Indice dell'elemento iniziale dell'intervallo da rimuovere.
toIndex => Indice dell'elemento dopo l'ultimo elemento nell'intervallo da rimuovere.
Valore di ritorno: vuoto
Descrizione: Rimuove gli elementi specificati nell'intervallo dato, daIndex (incluso) a toIndex (esclusivo) dall'elenco. Questa operazione riduce la lunghezza della lista di (toIndex-fromIndex). Questa operazione non ha effetto nel caso fromIndex = toIndex.
Eccezioni: IndexOutOfBoundsException => Se uno qualsiasi degli indici (fromIndex o toIndex) è fuori dai limiti.
Implementiamo un programma Java per dimostrare alcuni di questi metodi di rimozione di cui abbiamo discusso in precedenza.
import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(Arrays.asList('Delhi','Mumbai','Chennai', 'Kolkata', 'Pune', 'Hyderabad')); //print the list System.out.println('Initial ArrayList:' + city_List); //remove element at index 2 city_List.remove(2); //print the list System.out.println('
ArrayList after removing element at index 2:' + city_List); //remove the element 'Kolkata' city_List.remove('Kolkata'); //print the list System.out.println('
ArrayList after removing element -> Kolkata:' + city_List); //create new list ArrayList newCities=new ArrayList(Arrays.asList('Delhi','Hyderabad')); //call removeAll to remove elements contained in newCities list. city_List.removeAll(newCities); //print the list System.out.println('
ArrayList after call to removeAll:' + city_List); } }
Produzione:
Elenco di array iniziale: (Delhi, Mumbai, Chennai, Kolkata, Pune, Hyderabad
ArrayList dopo la rimozione dell'elemento all'indice 2: (Delhi, Mumbai, Kolkata, Pune, Hyderabad)
ArrayList dopo la rimozione dell'elemento -> Calcutta: (Delhi, Mumbai, Pune, Hyderabad)
ArrayList dopo la chiamata a removeAll: (Mumbai, Pune)
ArrayList size (Lunghezza)
Prototipo: int size ()
Parametri: NIL
Valore di ritorno: int => Numero di elementi in ArrayList.
Descrizione: Restituisce il numero totale di elementi o la lunghezza di ArrayList.
app per scaricare mp3 gratis per Android
Garantire la capacità
Prototipo: voiduranceCapacity (int minCapacity)
Parametri: minCapacity => La capacità minima desiderata per ArrayList.
Valore di ritorno: vuoto
Descrizione: Aumenta la capacità di ArrayList per garantire che abbia minCapacity.
trimToSize
Prototipo: void trimToSize ()
Parametri: NIL
Valore di ritorno: vuoto
Descrizione: Riduce la capacità di ArrayList alla dimensione o al numero di elementi presenti nell'elenco.
L'esempio di programmazione seguente mostra i metodi size (), sureCapacity () e trimToSize ().
import java.util.ArrayList; public class Main { public static void main(String () args) { //Create and initialize Arraylist ArrayList evenList=new ArrayList(5); System.out.println('Initial size: '+evenList.size()); evenList.add(2); evenList.add(4); evenList.add(6); evenList.add(8); evenList.add(10); //print the list and size System.out.println('Original List: ' + evenList); System.out.println('ArrayList Size after add operation: '+evenList.size()); //call ensureCapacity () with minimum capacity =10 evenList.ensureCapacity(10); //add two more elements evenList.add(12); evenList.add(14); //print the size again System.out.println('ArrayList Size after ensureCapacity() call and add operation: '+evenList.size()); //call trimToSize() evenList.trimToSize(); //print the size and the ArrayList System.out.println('ArrayList Size after trimToSize() operation: '+evenList.size()); System.out.println('ArrayList final: '); for(int num: evenList){ System.out.print(num + ' '); } } }
Produzione:
Dimensione iniziale: 0
Elenco originale: (2, 4, 6, 8, 10)
Dimensione ArrayList dopo l'operazione di aggiunta: 5
Dimensioni di ArrayList dopo la chiamata a sureCapacity () e l'operazione di aggiunta: 7
Dimensione ArrayList dopo l'operazione trimToSize (): 7
Finale di ArrayList:
2 4 6 8 10 12 14
ArrayList contiene
Prototipo: booleano contiene (Oggetto o)
Parametri: o => Elemento da verificare se presente nell'ArrayList.
Valore di ritorno: true => Se ArrayList contiene l'elemento o.
Descrizione: Controlla se l'elenco contiene l'elemento specificato 'o'. Restituisce vero se l'elemento è presente.
Utilizziamo il metodo 'contiene' nel seguente programma.
import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //call contains method to check if different strings are present in ArrayList System.out.println('ArrayList contains ('Red Green'): ' +colorsList.contains('Red Green')); System.out.println('ArrayList contains ('Blue'): ' +colorsList.contains('Blue')); System.out.println('ArrayList contains ('Yellow'): ' +colorsList.contains('Yellow')); System.out.println('ArrayList contains ('White'): ' +colorsList.contains('White')); } }
Produzione:
ArrayList contiene ('Red Green'): false
ArrayList contiene ('Blue'): true
ArrayList contiene ('Yellow'): false
ArrayList contiene ('White'): true
Come mostrato nell'output precedente, il metodo 'contiene' controlla se l'argomento fornito è presente in ArrayList e restituisce vero o falso.
ArrayList get
Prototipo: E get (int indice)
Parametri: index => Indice in cui l'elemento deve essere recuperato da ArrayList.
Valore di ritorno: E => Valore dell'elemento all'indice dato in ArrayList.
Descrizione: Restituisce l'elemento nell'elenco presente nella posizione specificata da 'index'.
Eccezioni: IndexOutOfBoundsException => Se l'indice è fuori dai limiti.
ArrayList set (Sostituisci elemento)
Prototipo: E set (int index, E element)
Parametri: index => Indice in cui l'elemento deve essere sostituito.
Elemento => Nuovo elemento da impostare all'indice specificato.
Valore di ritorno: E => Elemento che viene sostituito dall'operazione di set.
Descrizione: Imposta il valore dell'elemento in un dato 'indice' sul nuovo valore dato da 'elemento'.
Eccezioni: IndexOutOfBoundsException => Se l'indice è fuori dai limiti
Il programma Java seguente utilizza il metodo get () e set () per recuperare e sostituire i valori in ArrayList.
import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //call get () method to retrieve value at index 2 System.out.println('Entry at index 2 before call to set: ' + colorsList.get(2)); //replace the value at index 2 with new value colorsList.set(2,'Yellow'); //print the value at index 2 again System.out.println('Entry at index 2 after call to set: ' + colorsList.get(2)); } }
Produzione:
Voce all'indice 2 prima della chiamata al set: blu
Voce all'indice 2 dopo la chiamata al set: giallo
ArrayList clear
Prototipo: void clear ()
Parametri: NIL
Valore di ritorno: vuoto
Descrizione: Cancella l'elenco rimuovendo tutti gli elementi dall'elenco.
ArrayList isEmpty
Prototipo: booleano isEmpty ()
Parametri: NIL
Valore di ritorno: true => se l'elenco è vuoto
Descrizione: Controlla se l'elenco fornito è vuoto.
Le funzioni Clear () e isEmpty () sono illustrate di seguito.
import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //print the ArrayList System.out.println('The ArrayList: ' + colorsList); //call clear() nethod on ArrayList colorsList.clear(); //check if ArrayList is empty using isEmpty() method System.out.println('Is ArrayList empty after clear ()? :' + colorsList.isEmpty()); } }
Produzione:
The ArrayList: (Rosso, Verde, Blu, Bianco)
ArrayList è vuoto dopo clear ()? :vero
ArrayList indexOf
Prototipo: int indexOf (Oggetto o)
Parametri: o => Elemento il cui indice si trova in ArrayList.
Valore di ritorno: int => Indice della prima occorrenza dell'elemento nell'elenco.
Descrizione: Restituisce l'indice della prima occorrenza dell'elemento o nell'elenco. -1 se l'elemento o non è presente nell'elenco.
ArrayList lastIndexOf
Prototipo: int lastIndexOf (Object o)
Parametri: o => L'elemento da cercare.
Valore di ritorno: int => Indice dell'ultima occorrenza dell'elemento nell'elenco.
Descrizione: Restituisce l'indice dell'ultima occorrenza dell'elemento specificato o nell'elenco. -1 se l'elemento non è presente nell'elenco.
Il seguente programma Java mostra i metodi indexOf e lastIndexOf di ArrayList.
import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize intList ArrayList intList = new ArrayList(); intList.add(1); intList.add(1); intList.add(2); intList.add(3); intList.add(5); intList.add(3); intList.add(2); intList.add(1); intList.add(1); //print the ArrayList System.out.println('The ArrayList: ' + intList); //call indexOf() and lastIndexOf() methods to check the indices of specified elements System.out.println('indexOf(1) : ' + intList.indexOf(1)); System.out.println('lastIndexOf(1) : ' + intList.lastIndexOf(1)); System.out.println('indexOf(2) : ' + intList.indexOf(2)); System.out.println('lastIndexOf(2) : ' + intList.lastIndexOf(2)); System.out.println('indexOf(3) : ' + intList.indexOf(3)); System.out.println('lastIndexOf(3) : ' + intList.lastIndexOf(3)); System.out.println('indexOf(5) : ' + intList.indexOf(5)); System.out.println('lastIndexOf(5) : ' + intList.lastIndexOf(5)); } }
Produzione:
The ArrayList: (1, 1, 2, 3, 5, 3, 2, 1, 1)
indexOf (1): 0
lastIndexOf (1): 8
indexOf (2): 2
lastIndexOf (2): 6
indexOf (3): 3
lastIndexOf (3): 5
indexOf (5): 4
lastIndexOf (5): 4
ArrayList toArray
Prototipo: Object () toArray ()
Parametri: NIL
Valore di ritorno: Object () => un array. Questo array restituito contiene tutti gli elementi dell'elenco in una sequenza corretta.
Descrizione: Converte l'elenco fornito in un array.
Prototipo: T () toArray (T () a)
Parametri: a => Array per memorizzare gli elementi della lista. Se la dimensione dell'array non è sufficiente per gli elementi dell'elenco, viene creato un altro array con lo stesso tipo di a per memorizzare gli elementi.
Valore di ritorno: T () => Array che contiene tutti gli elementi della lista.
Descrizione: Converte l'elenco fornito in un array del tipo fornito da a.
Eccezioni: ArrayStoreException => Se c'è una mancata corrispondenza nel tipo di runtime dell'array e del tipo di runtime o del supertipo dei suoi elementi.
NullPointerException => L'array dato è nullo
Il programma Java riportato di seguito mostra il metodo toArray di ArrayList.
import java.util.*; public class Main { public static void main(String() args) { // define and initialize ArrayList ArrayList intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); // print ArrayList System.out.println('ArrayList: ' + intList); //declare array Integer myArray() = new Integer(intList.size()); //use toArray method to convert ArrayList to Array myArray = intList.toArray(myArray); //print the Array System.out.println('Array from ArrayList:' + Arrays.toString(myArray)); } }
Produzione:
Elenco array: (10, 20, 30, 40, 50)
Array da ArrayList: (10, 20, 30, 40, 50)
Clone di ArrayList
Prototipo: Oggetto clone ()
Parametri: NIL
Valore di ritorno: Object => Clone dell'istanza di ArrayList.
Descrizione: Crea una copia superficiale del dato ArrayList.
import java.util.ArrayList; public class Main { public static void main(String a()){ ArrayList fruitsList = new ArrayList(); //Adding elements to the ArrayList fruitsList.add('Apple'); fruitsList.add('Orange'); fruitsList.add('Melon'); fruitsList.add('Grapes'); System.out.println('Original ArrayList: '+fruitsList); ArrayList clone_list = (ArrayList)fruitsList.clone(); System.out.println('Cloned ArrayList: '+ clone_list); //add one elmeent & remove one element from original arraylist fruitsList.add('Mango'); fruitsList.remove('Orange'); //print original and cloned ArrayList again System.out.println('
Original ArrayList after add & remove:'+fruitsList); System.out.println('Cloned ArrayList after original changed:'+clone_list); } }
Produzione:
ArrayList originale: (Apple, Orange, Melon, Grapes)
Elenco array clonato: (Mela, arancia, melone, uva)
Elenco array originale dopo l'aggiunta e la rimozione: (Apple, Melon, Grapes, Mango)
Elenco array clonato dopo la modifica dell'originale: (Apple, Orange, Melon, Grapes)
Dall'output del programma sopra riportato, puoi vedere che ArrayList clonato è una copia superficiale dell'ArrayList originale. Ciò significa che quando viene modificato l'ArrayList originale, queste modifiche non si riflettono nell'ArrayList clonato poiché non condividono le posizioni di memoria di ciascun elemento.
Per creare una copia completa di Array, è necessario attraversare l'ArrayList originale e copiare ciascuno dei suoi elementi nell'ArrayList di destinazione.
ArrayList subList
Prototipo: List subList (int fromIndex, int toIndex)
Parametri: fromIndex => Indice iniziale dell'intervallo (compreso)
toIndex => Indice finale dell'intervallo (esclusivo)
Valore di ritorno: List => Sottolista della lista nell'intervallo dato.
Descrizione: Restituisce una sottolista tra un dato intervallo, da Indice a indice per l'elenco specificato. Notare che questa sottolista o la visualizzazione della lista nell'intervallo dato supporta tutte le operazioni supportate dalla lista. Nessuna visualizzazione viene restituita se fromIndex = toIndex.
Eccezioni: IndexOutOfBoundsException => Generato quando toIndex è fuori intervallo.
IllegalArgumentException => Se fromIndex> toIndex, ovvero gli indici sono fuori servizio.
Vediamo un esempio del metodo subList.
creazione di un albero di ricerca binario in java
import java.util.ArrayList; import java.util.List; class Main{ public static void main(String a()){ //create and initialize the ArrayList ArrayList intList = new ArrayList(); intList.add(5); intList.add(10); intList.add(15); intList.add(20); intList.add(25); intList.add(30); intList.add(35); intList.add(40); intList.add(45); intList.add(50); //print the ArrayList System.out.println('Original ArrayList: '+intList); //create a sublist for the given ArrayList ArrayList sub_ArrayList = new ArrayList(intList.subList(2, 6)); //print the sublist System.out.println('Sublist of given ArrayList: '+sub_ArrayList); } }
Produzione:
Elenco array originale: (5, 10, 15, 20, 25, 30, 35, 40, 45, 50)
Sottoelenco di un ArrayList dato: (15, 20, 25, 30)
ArrayList keepAll
Prototipo: boolean keepAll (Collection c)
Parametri: c => Raccolta con elementi che devono essere mantenuti nell'elenco.
Valore di ritorno: true => Se ArrayList è cambiato in seguito all'operazione.
Descrizione: Mantiene gli elementi nell'elenco che corrispondono agli elementi nella raccolta data c.
Eccezioni: ClassCastException => Il tipo di raccolta e il tipo di elenco non corrispondono
NullPointerException => La raccolta data è null o l'elenco contiene un elemento null e la raccolta non consente null.
Il seguente programma mostra il metodo keepAll.
import java.util.*; class Main{ public static void main(String args()){ //create and initialize ArrayList ArrayList colorsList=new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Yellow'); //print the ArrayList System.out.println('Original ArrayList:' + colorsList); //define another collection ArrayList color_collection=new ArrayList(); color_collection.add('Red'); color_collection.add('Blue'); System.out.println('Collection elements to be retained in the list:' + color_collection); //call retainAll method with above collection as an argument colorsList.retainAll(color_collection); //print the ArrayList after retainAll call. System.out.println('ArrayList after retainAll call:' + colorsList); } }
Produzione:
Elenco array originale: (rosso, verde, blu, giallo)
Elementi della raccolta da mantenere nell'elenco: (Rosso, Blu)
ArrayList dopo la chiamata RetainAll: (Red, Blue)
ArrayList Iterator
Prototipo: Iteratore iteratore ()
Parametri: NIL
Valore di ritorno: Iteratore => iteratore sugli elementi della lista.
Descrizione: Restituisce un iteratore per attraversare gli elementi della lista nella sequenza corretta.
ArrayList listIterator
IO.
Prototipo: ListIterator listIterator ()
Parametri: NIL
Valore di ritorno: ListIterator => listIterator sugli elementi della lista.
Descrizione: Restituisce l'iteratore della lista per attraversare gli elementi della lista data.
II.
Prototipo: ListIterator listIterator (int index)
Parametri: index => Posizione del primo elemento in listIterator.
Valore di ritorno: ListIterator => ListIterator per l'elenco dall'indice specificato.
Descrizione: Restituisce l'iteratore della lista a partire dalla posizione specificata 'index' per attraversare gli elementi della lista data.
Eccezioni: IndexOutOfBoundsException => L'indice specificato è fuori intervallo.
Esempio di metodi iterator () e listIterator ().
import java.util.*; class Main{ public static void main(String args()){ //create ArrayList and initialize it ArrayList cities=new ArrayList(); cities.add('Mumbai'); cities.add('Pune'); cities.add('Hyderabad'); cities.add('Delhi'); //use iterator() method to traverse through the list System.out.println('List contents using Iterator () method:'); Iterator iter=cities.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } //use listIterator() method to traverse through the list System.out.println('
List contents using listIterator () method:'); ListIterator list_iter=cities.listIterator(); while(list_iter.hasNext()) { System.out.print(list_iter.next() + ' '); } } }
Produzione:
Elenca i contenuti utilizzando il metodo Iterator ():
Mumbai Pune Hyderabad Delhi
Elenca i contenuti utilizzando il metodo listIterator ():
Mumbai Pune Hyderabad Delhi
Aggiungi array a ArrayList in Java
ArrayList supporta il metodo addAll per aggiungere elementi della raccolta a ArrayList. In modo simile, puoi anche aggiungere un Array a ArrayList. Ciò viene fatto utilizzando il metodo 'Collections.addAll'.
Esempio di aggiunta di un array a ArrayList.
import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(); //add elements to the ArrayList using add method city_List.add('Delhi'); city_List.add('Mumbai'); city_List.add('Chennai'); city_List.add('Kolkata'); //print ArrayList System.out.println('
Initial ArrayList :' + city_List); //define an array. String() myArray = new String(){'Cochin', 'Goa'}; //add the array to the ArrayList Collections.addAll(city_List,myArray); //print the ArrayList System.out.println('
ArrayList after adding array :' + city_List); } }
Produzione:
Elenco array iniziale: (Delhi, Mumbai, Chennai, Kolkata)
ArrayList dopo l'aggiunta dell'array: (Delhi, Mumbai, Chennai, Kolkata, Cochin, Goa)
Ordina ArrayList in Java
ArrayList utilizza il metodo Collections.sort per ordinare i suoi elementi. Per impostazione predefinita, l'elenco viene ordinato in ordine crescente dal metodo Collections.sort. Se ArrayList deve essere ordinato in ordine decrescente, è necessario fornire 'Collections.reverseOrder ()' un parametro al metodo di ordinamento.
Di seguito è riportato un programma per ordinare un ArrayList in ordine crescente e decrescente:
import java.util.*; public class Main { public static void main(String args()){ //Create and initialize an ArrayList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Yellow'); //print initial ArrayList System.out.println('Initial ArrayList:' + colorsList); //sort ArrayList in ascending order Collections.sort(colorsList); //print sorted ArrayList System.out.println('
ArrayList sorted in ascending order:'); System.out.println(colorsList); //sort ArrayList in reverse(desending) order Collections.sort(colorsList, Collections.reverseOrder()); //print sorted list System.out.println('
ArrayList sorted in descending order:'); System.out.println(colorsList); } }
Produzione:
Elenco array iniziale: (rosso, verde, blu, giallo)
ArrayList ordinato in ordine crescente:
(Blu, Verde, Rosso, Giallo)
ArrayList ordinato in ordine decrescente:
(Giallo, rosso, verde, blu)
Nel caso in cui ArrayList contenga altri oggetti di classe come elementi, è possibile utilizzare le interfacce Comparable e Comparator. Maggiori dettagli sulle interfacce saranno trattati nei nostri tutorial successivi.
Invertire un ArrayList in Java
Puoi anche invertire un ArrayList in Java. Un metodo per eseguire questa operazione è utilizzare il metodo tradizionale di attraversare l'ArrayList nell'ordine inverso e copiare ogni elemento in un nuovo ArrayList.
Un altro metodo è utilizzare la classe Collections che fornisce il metodo 'reverse' utilizzato per invertire una raccolta.
differenza tra port forward e port trigger
Di seguito viene fornito il programma per invertire un ArrayList utilizzando la classe Collections.
import java.io.*; import java.util.*; public class Main { public static void main(String() args) { // create and initialize an ArrayList ArrayList oddList = new ArrayList(); oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); System.out.print('Initial ArrayList: ' + oddList); // use Collections.reverse method to reverse the ArrayList Collections.reverse(oddList); //print the ArrayList System.out.print('
Reversed ArrayList: ' + oddList); } }
Produzione:
Elenco array iniziale: (1, 3, 5, 7, 9)
Elenco array inverso: (9, 7, 5, 3, 1)
Rimuovi i duplicati da un ArrayList in Java
Per rimuovere i duplicati da ArrayList, è possibile ricorrere ancora una volta al metodo tradizionale di utilizzare un iteratore per attraversare ArrayList e memorizzare solo la prima occorrenza dell'elemento in un ArrayList diverso.
Ancora un altro metodo consiste nell'usare il metodo 'separate ()' della classe stream (). Questo metodo restituisce un flusso di elementi distinti. La funzione stream () è disponibile in Java da Java 8 in poi.
L'implementazione del metodo stream () .distinct () è fornita di seguito:
import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String() args) { // Create an ArrayList of numbers ArrayList numList = new ArrayList (Arrays.asList(1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)); //print the original ArrayList System.out.println('Original ArrayList:' + numList); //Use Java 8 stream().distinct() method to remove duplicates from the list List distinctList = numList.stream().distinct().collect(Collectors.toList()); //print the new list System.out.println('ArrayList without duplicates:' + distinctList); } }
Produzione:
Elenco array originale: (1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)
ArrayList senza duplicati: (1, 2, 3, 5, 6, 7, 8)
Shuffle (Randomize) An ArrayList in Java
Puoi anche 'mescolare' o randomizzare gli elementi di ArrayList. Questo viene fatto utilizzando il metodo Collections.shuffle (). Usando questo metodo, puoi mescolare ArrayList con le impostazioni predefinite o fornire una funzione random () che randomizzerà gli elementi in base al valore casuale fornito.
Di seguito viene fornito un programma Java per ottenere ciò.
import java.util.*; public class Main { public static void main(String() args) { //create and initialize a String ArrayList ArrayList strlist = new ArrayList(); strlist.add('east'); strlist.add('west'); strlist.add('north'); strlist.add('south'); strlist.add('southwest'); strlist.add('northeast'); //print the original list System.out.println('Original ArrayList :
' + strlist); //shuffle the ArrayList without random function Collections.shuffle(strlist); System.out.println('
Shuffled ArrayList without Random() :
' + strlist); // shuffle the ArrayList with random() function Collections.shuffle(strlist, new Random()); System.out.println('
Shuffled ArrayList with Random() :
' + strlist); // use random (2) to shuffle the ArrayList Collections.shuffle(strlist, new Random(2)); System.out.println('
Shuffled ArrayList with Random(2) :
' + strlist); } }
Produzione:
Elenco di array originale: (est, ovest, nord, sud, sud-ovest, nord-est) Elenco di array mescolato senza casuale (): (nord, nord-est, est, sud-ovest, sud, ovest)
Elenco di array mescolato con casuale (): (sud, est, nord, nord-est, ovest, sud-ovest)
Elenco di array mescolato con casuale (2): (sud-ovest, sud, est, nord-est, nord, ovest)
Domande frequenti
D # 1) Qual è la differenza tra contenitori omogenei ed eterogenei in Java?
Risposta: I contenitori omogenei contengono oggetti / elementi dello stesso tipo. D'altra parte, i contenitori eterogenei hanno oggetti di tipo misto.
Q # 2) ArrayList in Java è eterogeneo?
Risposta: Sì. Poiché ArrayList supporta i generici e quindi la cancellazione del tipo, può contenere oggetti misti quando implementato come un ArrayList generico.
Q # 3) ArrayList può archiviare int?
Risposta: No. ArrayLists non può memorizzare valori come int ma può memorizzare oggetti Integer poiché ArrayLists può contenere solo oggetti. Quindi per memorizzare i tipi primitivi dovresti usare classi wrapper come Integer per gli int.
Q # 4) Cosa succede quando ArrayList è pieno?
Risposta: Ogni oggetto ArrayList ha una funzione denominata 'capacità'. Quando ArrayList è pieno, la capacità di ArrayList aumenta automaticamente per fare spazio a più elementi.
Q # 5) Qual è la differenza tra il metodo removeAll e keepAll in ArrayList?
Risposta: I metodi 'removeAll' e 'keepAll' di ArrayList mostrano un comportamento opposto.
Mentre il metodo removeAll rimuove tutti gli elementi dall'elenco che corrispondono alla raccolta passata come argomento a questo metodo, keepAll, d'altra parte, conserva tutti gli elementi nell'elenco che corrispondono a quello della raccolta.
Conclusione
In questo tutorial, abbiamo discusso in dettaglio i metodi ArrayList con un esempio.
Abbiamo anche considerato alcuni casi speciali come l'aggiunta di elementi all'inizio dell'elenco. Abbiamo anche discusso di altre operazioni su ArrayList come l'ordinamento, l'inversione e lo shuffling di ArrayList.
Nel nostro prossimo tutorial, discuteremo alcune delle conversioni di ArrayList.
=> Guarda qui la serie di formazione su Java semplice.
Lettura consigliata
- Tutorial Java Reflection con esempi
- Tutorial Java String | Metodi Java String con esempi
- Metodi elenco Java - Ordina elenco, Contiene, Aggiungi elenco, Rimuovi elenco
- Java ArrayList - Come dichiarare, inizializzare e stampare un ArrayList
- Conversioni di Java ArrayList in altre raccolte
- Tutorial Java SWING: contenitore, componenti e gestione degli eventi
- Invertire un array in Java - 3 metodi con esempi
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici