TechCodeview

Giava Lista di array la classe usa a dinamico vettore per riporre gli elementi. È come un array, ma c'è nessun limite di dimensione . Possiamo aggiungere o rimuovere elementi in qualsiasi momento. Quindi, è molto più flessibile dell'array tradizionale. Si trova nel java.util pacchetto. È come il vettore in C++.

Anche l'ArrayList in Java può avere elementi duplicati. Implementa l'interfaccia List in modo che qui possiamo utilizzare tutti i metodi dell'interfaccia List. L'ArrayList mantiene internamente l'ordine di inserimento.

Eredita la classe AbstractList e la implementa Interfaccia elenco .

I punti importanti sulla classe Java ArrayList sono:

• La classe Java ArrayList può contenere elementi duplicati.
• La classe Java ArrayList mantiene l'ordine di inserimento.
• La classe Java ArrayList non lo è sincronizzato .
• Java ArrayList consente l'accesso casuale perché l'array funziona su base indice.
• In ArrayList, la manipolazione è un po' più lenta rispetto a LinkedList in Java perché è necessario che si verifichino molti spostamenti se un elemento viene rimosso dall'elenco dell'array.
• Non possiamo creare un elenco di array dei tipi primitivi, come int, float, char, ecc. In questi casi è necessario utilizzare la classe wrapper richiesta. Per esempio:

 ArrayList al = ArrayList(); // does not work ArrayList al = new ArrayList(); // works fine 

• Java ArrayList viene inizializzato in base alla dimensione. La dimensione è dinamica nell'elenco dell'array e varia a seconda degli elementi aggiunti o rimossi dall'elenco.

Gerarchia della classe ArrayList

Come mostrato nel diagramma sopra, la classe Java ArrayList estende la classe AbstractList che implementa l'interfaccia List. L'interfaccia Elenco estende il file Collezione e Interfacce iterabili in ordine gerarchico.

Dichiarazione della classe ArrayList

Vediamo la dichiarazione per la classe java.util.ArrayList.

 public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable 

Costruttori di ArrayList

Metodi di ArrayList

Java non generico vs. Collezione generica

Il framework di raccolta Java non era generico prima di JDK 1.5. Dalla versione 1.5 è generico.

La nuova raccolta generica Java consente di avere un solo tipo di oggetto in una raccolta. Ora è indipendente dai tipi, quindi il typecasting non è richiesto in fase di esecuzione.

Vediamo il vecchio esempio non generico di creazione di una raccolta Java.

 ArrayList list=new ArrayList();//creating old non-generic arraylist 

Vediamo il nuovo esempio generico di creazione di una raccolta Java.

 ArrayList list=new ArrayList();//creating new generic arraylist 

In una raccolta generica, specifichiamo il tipo tra parentesi angolari. Ora ArrayList è obbligato a contenere l'unico tipo di oggetto specificato. Se provi ad aggiungere un altro tipo di oggetto, viene visualizzato a errore in fase di compilazione .

Per ulteriori informazioni sui generici Java, fare clic qui Tutorial sui generici Java .

Esempio di elenco di array Java

Nome del file: ArrayListEsempio1.java

 import java.util.*; public class ArrayListExample1{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Printing the arraylist object System.out.println(list); } } 

Produzione:

[Mango, Apple, Banana, Grapes] 

Iterazione di ArrayList utilizzando Iterator

Vediamo un esempio per attraversare gli elementi ArrayList utilizzando l'interfaccia Iterator.

Nome del file: ArrayListExample2.java

 import java.util.*; public class ArrayListExample2{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Traversing list through Iterator Iterator itr=list.iterator();//getting the Iterator while(itr.hasNext()){//check if iterator has the elements System.out.println(itr.next());//printing the element and move to next } } } 

Produzione:

Mango Apple Banana Grapes 

Iterazione di ArrayList utilizzando il ciclo For-each

Vediamo un esempio per attraversare gli elementi ArrayList utilizzando il ciclo for-each

Nome del file: ArrayListEsempio3.java

 import java.util.*; public class ArrayListExample3{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Traversing list through for-each loop for(String fruit:list) System.out.println(fruit); } } 

Produzione:

Mango Apple Banana Grapes 

Ottieni e imposta ArrayList

IL metodo get() restituisce l'elemento all'indice specificato, mentre il metodo set() cambia l'elemento.

Nome del file: ArrayListExample4.java

 import java.util.*; public class ArrayListExample4{ public static void main(String args[]){ ArrayList al=new ArrayList(); al.add('Mango'); al.add('Apple'); al.add('Banana'); al.add('Grapes'); //accessing the element System.out.println('Returning element: '+al.get(1));//it will return the 2nd element, because index starts from 0 //changing the element al.set(1,'Dates'); //Traversing list for(String fruit:al) System.out.println(fruit); } } 

Produzione:

Returning element: Apple Mango Dates Banana Grapes 

Come ordinare ArrayList

IL java.util Il pacchetto fornisce una classe di utilità Collezioni , che ha il metodo statico sort(). Usando il Collezioni.sort() metodo, possiamo facilmente ordinare ArrayList.

Nome del file: SortArrayList.java

 import java.util.*; class SortArrayList{ public static void main(String args[]){ //Creating a list of fruits List list1=new ArrayList(); list1.add('Mango'); list1.add('Apple'); list1.add('Banana'); list1.add('Grapes'); //Sorting the list Collections.sort(list1); //Traversing list through the for-each loop for(String fruit:list1) System.out.println(fruit); System.out.println('Sorting numbers...'); //Creating a list of numbers List list2=new ArrayList(); list2.add(21); list2.add(11); list2.add(51); list2.add(1); //Sorting the list Collections.sort(list2); //Traversing list through the for-each loop for(Integer number:list2) System.out.println(number); } } 

Produzione:

Apple Banana Grapes Mango Sorting numbers... 1 11 21 51 

Modi per ripetere gli elementi della raccolta in Java

Esistono vari modi per attraversare gli elementi della raccolta:

1. Tramite l'interfaccia Iterator.
2. Per ogni ciclo.
3. Tramite l'interfaccia ListIterator.
4. Con il ciclo for.
5. Con il metodo forEach().
6. Con il metodo forEachRemaining().

Iterazione della raccolta attraverso le modalità rimanenti

Vediamo un esempio per attraversare gli elementi ArrayList in altri modi

Nome del file: ArrayList4.java

 import java.util.*; class ArrayList4{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add(&apos;Ravi&apos;);//Adding object in arraylist list.add(&apos;Vijay&apos;); list.add(&apos;Ravi&apos;); list.add(&apos;Ajay&apos;); System.out.println(&apos;Traversing list through List Iterator:&apos;); //Here, element iterates in reverse order ListIterator list1=list.listIterator(list.size()); while(list1.hasPrevious()) { String str=list1.previous(); System.out.println(str); } System.out.println(&apos;Traversing list through for loop:&apos;); for(int i=0;i<list.size();i++) { system.out.println(list.get(i)); } system.out.println('traversing list through foreach() method:'); the method is a new feature, introduced in java 8. list.foreach(a->{ //Here, we are using lambda expression System.out.println(a); }); System.out.println(&apos;Traversing list through forEachRemaining() method:&apos;); Iterator itr=list.iterator(); itr.forEachRemaining(a-&gt; //Here, we are using lambda expression { System.out.println(a); }); } } </list.size();i++)>

Produzione:

Traversing list through List Iterator: Ajay Ravi Vijay Ravi Traversing list through for loop: Ravi Vijay Ravi Ajay Traversing list through forEach() method: Ravi Vijay Ravi Ajay Traversing list through forEachRemaining() method: Ravi Vijay Ravi Ajay 

Oggetti di classe definiti dall'utente in Java ArrayList

Vediamo un esempio in cui stiamo memorizzando l'oggetto della classe Student in un elenco di array.

Nome del file: ArrayList5.java

 class Student{ int rollno; String name; int age; Student(int rollno,String name,int age){ this.rollno=rollno; this.name=name; this.age=age; } } 

 import java.util.*; class ArrayList5{ public static void main(String args[]){ //Creating user-defined class objects Student s1=new Student(101,'Sonoo',23); Student s2=new Student(102,'Ravi',21); Student s2=new Student(103,'Hanumat',25); //creating arraylist ArrayList al=new ArrayList(); al.add(s1);//adding Student class object al.add(s2); al.add(s3); //Getting Iterator Iterator itr=al.iterator(); //traversing elements of ArrayList object while(itr.hasNext()){ Student st=(Student)itr.next(); System.out.println(st.rollno+' '+st.name+' '+st.age); } } } 

Produzione:

 101 Sonoo 23 102 Ravi 21 103 Hanumat 25 

Esempio di serializzazione e deserializzazione di Java ArrayList

Vediamo un esempio per serializzare un oggetto ArrayList e poi deserializzarlo.

Nome del file: ArrayList6.java

 import java.io.*; import java.util.*; class ArrayList6 { public static void main(String [] args) { ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); try { //Serialization FileOutputStream fos=new FileOutputStream('file'); ObjectOutputStream oos=new ObjectOutputStream(fos); oos.writeObject(al); fos.close(); oos.close(); //Deserialization FileInputStream fis=new FileInputStream('file'); ObjectInputStream ois=new ObjectInputStream(fis); ArrayList list=(ArrayList)ois.readObject(); System.out.println(list); }catch(Exception e) { System.out.println(e); } } } 

Produzione:

 [Ravi, Vijay, Ajay] 

Esempio Java ArrayList per aggiungere elementi

Qui vediamo diversi modi per aggiungere un elemento.

Nome del file: ArrayList7.java

 import java.util.*; class ArrayList7{ public static void main(String args[]){ ArrayList al=new ArrayList(); System.out.println('Initial list of elements: '+al); //Adding elements to the end of the list al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); System.out.println('After invoking add(E e) method: '+al); //Adding an element at the specific position al.add(1, 'Gaurav'); System.out.println('After invoking add(int index, E element) method: '+al); ArrayList al2=new ArrayList(); al2.add('Sonoo'); al2.add('Hanumat'); //Adding second list elements to the first list al.addAll(al2); System.out.println('After invoking addAll(Collection c) method: '+al); ArrayList al3=new ArrayList(); al3.add('John'); al3.add('Rahul'); //Adding second list elements to the first list at specific position al.addAll(1, al3); System.out.println('After invoking addAll(int index, Collection c) method: '+al); } } 

Produzione:

Initial list of elements: [] After invoking add(E e) method: [Ravi, Vijay, Ajay] After invoking add(int index, E element) method: [Ravi, Gaurav, Vijay, Ajay] After invoking addAll(Collection c) method: [Ravi, Gaurav, Vijay, Ajay, Sonoo, Hanumat] After invoking addAll(int index, Collection c) method: [Ravi, John, Rahul, Gaurav, Vijay, Ajay, Sonoo, Hanumat] 

Esempio Java ArrayList per rimuovere elementi

Qui vediamo diversi modi per rimuovere un elemento.

Nome del file: ArrayList8.java

 import java.util.*; class ArrayList8 { public static void main(String [] args) { ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); al.add('Anuj'); al.add('Gaurav'); System.out.println('An initial list of elements: '+al); //Removing specific element from arraylist al.remove('Vijay'); System.out.println('After invoking remove(object) method: '+al); //Removing element on the basis of specific position al.remove(0); System.out.println('After invoking remove(index) method: '+al); //Creating another arraylist ArrayList al2=new ArrayList(); al2.add('Ravi'); al2.add('Hanumat'); //Adding new elements to arraylist al.addAll(al2); System.out.println('Updated list : '+al); //Removing all the new elements from arraylist al.removeAll(al2); System.out.println('After invoking removeAll() method: '+al); //Removing elements on the basis of specified condition al.removeIf(str -> str.contains('Ajay')); //Here, we are using Lambda expression System.out.println('After invoking removeIf() method: '+al); //Removing all the elements available in the list al.clear(); System.out.println('After invoking clear() method: '+al); } } 

Produzione:

An initial list of elements: [Ravi, Vijay, Ajay, Anuj, Gaurav] After invoking remove(object) method: [Ravi, Ajay, Anuj, Gaurav] After invoking remove(index) method: [Ajay, Anuj, Gaurav] Updated list : [Ajay, Anuj, Gaurav, Ravi, Hanumat] After invoking removeAll() method: [Ajay, Anuj, Gaurav] After invoking removeIf() method: [Anuj, Gaurav] After invoking clear() method: [] 

Esempio Java ArrayList del metodo keepAll()

Nome del file: ArrayList9.java

 import java.util.*; class ArrayList9{ public static void main(String args[]){ ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); ArrayList al2=new ArrayList(); al2.add('Ravi'); al2.add('Hanumat'); al.retainAll(al2); System.out.println('iterating the elements after retaining the elements of al2'); Iterator itr=al.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Produzione:

 iterating the elements after retaining the elements of al2 Ravi 

Esempio Java ArrayList del metodo isEmpty()

Nome del file: ArrayList4.java

 import java.util.*; class ArrayList10{ public static void main(String [] args) { ArrayList al=new ArrayList(); System.out.println('Is ArrayList Empty: '+al.isEmpty()); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); System.out.println('After Insertion'); System.out.println('Is ArrayList Empty: '+al.isEmpty()); } } 

Produzione:

algoritmo knn

Is ArrayList Empty: true After Insertion Is ArrayList Empty: false 

Esempio di elenco di array Java: libro

Vediamo un esempio di ArrayList in cui aggiungiamo libri all'elenco e stampiamo tutti i libri.

Nome del file: ArrayListExample20.java

 import java.util.*; class Book { int id; String name,author,publisher; int quantity; public Book(int id, String name, String author, String publisher, int quantity) { this.id = id; this.name = name; this.author = author; this.publisher = publisher; this.quantity = quantity; } } public class ArrayListExample20 { public static void main(String[] args) { //Creating list of Books List list=new ArrayList(); //Creating Books Book b1=new Book(101,'Let us C','Yashwant Kanetkar','BPB',8); Book b2=new Book(102,'Data Communications and Networking','Forouzan','Mc Graw Hill',4); Book b3=new Book(103,'Operating System','Galvin','Wiley',6); //Adding Books to list list.add(b1); list.add(b2); list.add(b3); //Traversing list for(Book b:list){ System.out.println(b.id+' '+b.name+' '+b.author+' '+b.publisher+' '+b.quantity); } } } 

Produzione:

101 Let us C Yashwant Kanetkar BPB 8 102 Data Communications and Networking Forouzan Mc Graw Hill 4 103 Operating System Galvin Wiley 6 

Dimensioni e capacità di un ArrayList

Dimensioni e capacità di un elenco di array sono i due termini che i principianti trovano confusi. Capiamolo in questa sezione con l'aiuto di alcuni esempi. Considera il seguente frammento di codice.

Nome del file: DimensioneCapacità.java

 import java.util.*; public class SizeCapacity { public static void main(String[] args) throws Exception { ArrayList al = new ArrayList(); System.out.println('The size of the array is: ' + al.size()); } } 

Produzione:

 The size of the array is: 0 

Spiegazione: L'output ha senso poiché non abbiamo fatto nulla con l'elenco degli array. Ora osserva il seguente programma.

Nome del file: Capacitàdimensione1.java

 import java.util.*; public class SizeCapacity1 { public static void main(String[] args) throws Exception { ArrayList al = new ArrayList(10); System.out.println('The size of the array is: ' + al.size()); } } 

Produzione:

 The size of the array is: 0 

Spiegazione: Vediamo che la dimensione è ancora 0 e il motivo è che il numero 10 rappresenta la capacità e non la dimensione. Infatti la dimensione rappresenta il numero totale di elementi presenti nell'array. Poiché non abbiamo aggiunto alcun elemento, quindi, la dimensione dell'elenco degli array è zero in entrambi i programmi.

La capacità rappresenta il numero totale di elementi che l'elenco dell'array può contenere. Pertanto, la capacità di un elenco di array è sempre maggiore o uguale alla dimensione dell'elenco di array. Quando aggiungiamo un elemento all'elenco dell'array, controlla se la dimensione dell'elenco dell'array è diventata uguale alla capacità o meno. In caso affermativo, la capacità dell'elenco di array aumenta. Quindi, nell'esempio sopra, la capacità sarà di 10 finché non verranno aggiunti 10 elementi all'elenco. Quando aggiungiamo 11^thelemento, la capacità aumenta. Si noti che in entrambi gli esempi la capacità dell'elenco di array è 10. Nel primo caso, la capacità è 10 perché la capacità predefinita dell'elenco di array è 10. Nel secondo caso, abbiamo esplicitamente menzionato che la capacità dell'array l'elenco è 10.

Nota: non esiste un metodo standard per stabilire come aumenta la capacità nell'elenco degli array. Infatti, il modo in cui la capacità aumenta varia da una versione GDK all'altra versione. Pertanto, è necessario verificare il modo in cui il codice di aumento della capacità viene implementato nel GDK. Non esiste alcun metodo predefinito nella classe ArrayList che restituisca la capacità dell'elenco di array. Pertanto, per una migliore comprensione, utilizzare il metodo capacità() della classe Vector. La logica della dimensione e della capacità è la stessa nella classe ArrayList e nella classe Vector.

Argomenti correlati

Come ordinare ArrayList in Java

Differenza tra Array e ArrayList

Quando utilizzare ArrayList e LinkedList in Java

Differenza tra ArrayList e LinkedList

Differenza tra ArrayList e Vector

Come confrontare due ArrayList in Java

Come invertire ArrayList in Java

Quando utilizzare ArrayList e LinkedList in Java

Come rendere ArrayList di sola lettura

Differenza tra la lunghezza dell'array e la dimensione() di ArrayList in Java

Come sincronizzare ArrayList in Java

Come convertire ArrayList in Array e Array in ArrayList in Java

Array vs ArrayList in Java

Come ordinare Java ArrayList in ordine decrescente

Come rimuovere i duplicati da ArrayList in Java