Elenco array Java fa parte di Java quadro delle collezioni ed è una classe del pacchetto java.util. Ci fornisce array dinamici in Java. Tuttavia, potrebbe essere più lento degli array standard ma può essere utile nei programmi in cui è necessaria molta manipolazione nell'array. Questa classe si trova in java.util pacchetto. Il principale vantaggio di ArrayList in Java è che se dichiariamo un array allora dobbiamo menzionare la dimensione, ma in ArrayList non è necessario menzionare la dimensione di ArrayList. Se vuoi menzionare la taglia, puoi farlo.

Tabella dei contenuti

• Cos'è ArrayList in Java?
• Esempio di elenco di array Java
• Caratteristiche importanti di ArrayList in Java
• Costruttori in ArrayList
• ArrayList nei metodi Java
• Operazioni eseguite in ArrayList
• Complessità di Java ArrayList
• Vantaggi di Java ArrayList
• Svantaggi di Java ArrayList
• Conclusione
• Domande frequenti su ArrayList

Cos'è ArrayList in Java?

ArrayList è una classe Java implementata utilizzando l'interfaccia List. Java ArrayList, come suggerisce il nome, fornisce la funzionalità di un array dinamico in cui la dimensione non è fissa come array. Inoltre, come parte del framework Collections, presenta molte funzionalità non disponibili con gli array.

jpulsante

Illustrazione:

Controlliamo l'ArrayList con il tipo di oggetto Integer memorizzato al suo interno con un'immagine.

Esempio di elenco di array Java

Esempio 1: L'implementazione seguente mostra come creare e utilizzare un ArrayList menzionandone le dimensioni.

// Java program to demonstrate the // working of ArrayList import java.io.*; import java.util.*; class ArrayListExample {  public static void main(String[] args)  {  // Size of the  // ArrayList  int n = 5;  // Declaring the ArrayList with  // initial size n  ArrayList arr1 = nuovo ArrayList (N);  // Dichiarazione di ArrayList ArrayList arr2 = nuovo ArrayList ();  // Stampa dell'ArrayList System.out.println('Array 1:' + arr1);  System.out.println('Array 2:' + arr2);  // Aggiunge nuovi elementi alla // fine dell'elenco for (int i = 1; i<= n; i++) {  arr1.add(i);  arr2.add(i);  }  // Printing the ArrayList  System.out.println('Array 1:' + arr1);  System.out.println('Array 2:' + arr2);  } }>

Array 1:[] Array 2:[] Array 1:[1, 2, 3, 4, 5] Array 2:[1, 2, 3, 4, 5]>

Spiegazione del programma di cui sopra:

ArrayList è un array dinamico e non dobbiamo specificare la dimensione durante la creazione, la dimensione dell'array aumenta automaticamente quando aggiungiamo e rimuoviamo dinamicamente elementi. Sebbene l'effettiva implementazione della libreria possa essere più complessa, quella che segue è un'idea molto semplice che spiega il funzionamento dell'array quando l'array diventa pieno e se proviamo ad aggiungere un elemento:

• Crea una memoria di dimensioni maggiori sulla memoria heap (ad esempio memoria di dimensione doppia).
• Copia gli elementi della memoria corrente nella nuova memoria.
• Il nuovo elemento viene aggiunto ora poiché ora è disponibile una memoria più grande.
• Elimina la vecchia memoria.

Caratteristiche importanti di ArrayList in Java

• ArrayList eredita AbstractList classe e implementa il file Interfaccia elenco .
• ArrayList viene inizializzato in base alla dimensione. Tuttavia, la dimensione viene aumentata automaticamente se la raccolta aumenta o si riduce se il file oggetti vengono rimossi dalla raccolta.
• Java ArrayList ci consente di accedere in modo casuale all'elenco.
• ArrayList non può essere utilizzato per classe involucro per tali casi.
• ArrayList in Java può essere visto come a vettore in C++ .
• ArrayList non è sincronizzato. La sua classe sincronizzata equivalente in Java è Vettore .

Capiamo il Java ArrayList in modo approfondito . Guarda l'immagine qui sotto:

Nell'illustrazione sopra, AbstractList , CopyOnWriteArrayList , E AbstractSequentialList sono le classi che implementano l'interfaccia list. In ciascuna delle classi menzionate è implementata una funzionalità separata. Sono:

1. Elenco astratto: Questa classe viene utilizzata per implementare un elenco immodificabile, per il quale è necessario estendere solo questa classe AbstractList e implementare solo il Ottenere() e il misurare() metodi.
2. CopyOnWriteArrayList: Questa classe implementa l'interfaccia dell'elenco. È una versione migliorata di Lista di array in cui tutte le modifiche (aggiunta, impostazione, rimozione, ecc.) vengono implementate creando una nuova copia dell'elenco.
3. Elencosequenzialeastratto: Questa classe implementa il Interfaccia di raccolta e la classe AbstractCollection. Questa classe viene utilizzata per implementare un elenco immodificabile, per il quale è necessario estendere solo questa classe AbstractList e implementare solo il Ottenere() e il misurare() metodi.

Costruttori in ArrayList in Java

Per creare un ArrayList, dobbiamo creare un oggetto della classe ArrayList. La classe ArrayList è composta da vari costruttori che permettono l'eventuale creazione della lista degli array. Di seguito sono riportati i costruttori disponibili in questa classe:

1.ArrayList()

Questo costruttore viene utilizzato per creare un elenco di array vuoto. Se desideriamo creare un ArrayList vuoto con il nome arr , quindi, può essere creato come:

ArrayList arr = new ArrayList();>

2. ArrayList (raccolta c)

Questo costruttore viene utilizzato per creare un elenco di array inizializzato con gli elementi della raccolta c. Supponiamo di voler creare un ArrayList arr che contenga gli elementi presenti nella collection c, quindi potrà essere creato come:

ArrayList arr = new ArrayList(c);>

3. ArrayList (capacità int)

Questo costruttore viene utilizzato per creare un elenco di array con la capacità iniziale specificata. Supponiamo di voler creare un ArrayList con la dimensione iniziale N, quindi può essere creato come:

ArrayList arr = new ArrayList(N);>

Metodi Java ArrayList

Nota: Puoi anche creare un ArrayList generico:

// Creazione di ArrayList interi generici
ArrayList arrli = new ArrayList();

topologia di rete

Alcuni punti chiave di ArrayList in Java

1. ArrayList è una struttura di dati sottolineata Array ridimensionabile o Array espandibile.
2. Sono consentiti duplicati di ArrayList.
3. L'ordine di inserimento viene mantenuto.
4. Sono ammessi oggetti eterogenei.
5. È possibile l'inserimento di null.

Vediamo come eseguire alcune operazioni di base sull'ArrayList elencato di cui parleremo ulteriormente insieme all'implementazione di ogni operazione.

• Aggiunta di un elemento all'elenco/Aggiungi elemento
• Modifica elementi/Imposta elemento
• Rimuovere elementi/Eliminare elemento
• Elementi iterativi
• ottenere elementi
• aggiungi elementi tra due numeri
• Ordinamento degli elementi
• Dimensioni dell'elenco di array

Operazioni eseguite in ArrayList

1. Aggiunta di elementi

Per aggiungere un elemento a un ArrayList, possiamo usare il file metodo add() . Questo metodo è sovraccaricato per eseguire più operazioni in base a parametri diversi. Sono i seguenti:

• add(Object): questo metodo viene utilizzato per aggiungere un elemento alla fine dell'ArrayList.
• add(int indice, Oggetto): questo metodo viene utilizzato per aggiungere un elemento a un indice specifico nell'ArrayList.

Di seguito è riportata l’implementazione dell’approccio di cui sopra:

// Java Program to Add elements to An ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Array of string type  ArrayListal = nuovo ArrayList();  // Aggiunta di elementi a ArrayList // Ingressi personalizzati al.add('Geeks');  al.add('Geeks');  // Qui menzioniamo l'indice // al quale deve essere aggiunto al.add(1, 'For');  // Stampa tutti gli elementi in un ArrayList System.out.println(al);  } }>

[Geeks, For, Geeks]>

2. Modifica degli elementi

Dopo aver aggiunto gli elementi, se desideriamo modificare l'elemento, possiamo farlo utilizzando il file impostato() metodo. Poiché un ArrayList è indicizzato, l'elemento che desideriamo modificare viene referenziato dall'indice dell'elemento. Pertanto, questo metodo accetta un indice e l'elemento aggiornato che deve essere inserito in quell'indice.

Di seguito è riportata l’implementazione dell’approccio di cui sopra:

// Java Program to Change elements in ArrayList // Importing all utility classes import java.util.*; // main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Arraylist object of string type  ArrayListal = nuovo ArrayList();  // Aggiunta di elementi all'Arraylist // Elementi di input personalizzati al.add('Geeks');  al.add('Geeks');  // Aggiunta specificando l'indice da aggiungere al.add(1, 'Geeks');  // Stampa degli elementi dell'Arraylist System.out.println('Initial ArrayList ' + al);  // Impostazione dell'elemento al 1° indice al.set(1, 'For');  // Stampa dell'Arraylist aggiornato System.out.println('ArrayList aggiornato ' + al);  } }>

Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>

3. Rimozione di elementi

Per rimuovere un elemento da un ArrayList, possiamo usare il file metodo rimuovi() . Questo metodo è sovraccaricato per eseguire più operazioni in base a parametri diversi. Sono i seguenti:

• rimuovi(Oggetto): Questo metodo viene utilizzato per rimuovere semplicemente un oggetto dall'ArrayList. Se sono presenti più oggetti di questo tipo, viene rimossa la prima occorrenza dell'oggetto.
• rimuovi(int indice): Poiché un ArrayList è indicizzato, questo metodo accetta un valore intero che rimuove semplicemente l'elemento presente in quell'indice specifico nell'ArrayList. Dopo aver rimosso l'elemento, tutti gli elementi vengono spostati a sinistra per riempire lo spazio e gli indici degli oggetti vengono aggiornati.

Esempio:

// Java program to Remove Elements in ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an object of arraylist class  ArrayListal = nuovo ArrayList();  // Aggiunta di elementi a ArrayList // Aggiunta personalizzata al.add('Geeks');  al.add('Geeks');  // Aggiunta di un elemento all'indice specifico al.add(1, 'For');  // Stampa tutti gli elementi di ArrayList System.out.println('Initial ArrayList ' + al);  // Rimozione dell'elemento dall'alto ArrayList al.remove(1);  // Stampa degli elementi aggiornati dell'Arraylist System.out.println('After the Index Removal ' + al);  // Rimozione di questo elemento parola in ArrayList al.remove('Geeks');  // Ora sto stampando l'ArrayList aggiornato System.out.println('Dopo la rimozione dell'oggetto' + al);  } }>

Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>

4. Iterazione dell'ArrayList

Esistono diversi modi per scorrere l'ArrayList. I modi più famosi sono utilizzando il basic per ciclo in combinazione con a metodo get() per ottenere l'elemento in un indice specifico e il avanzato per un ciclo .

Esempio

// Java program to Iterate the elements // in an ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Arraylist of string type  ArrayListal = nuovo ArrayList();  // Aggiunta di elementi a ArrayList // utilizzando il metodo standard add() al.add('Geeks');  al.add('Geeks');  al.add(1, 'Per');  // Utilizzando il metodo Get e il // ciclo for for (int i = 0; i< al.size(); i++) {  System.out.print(al.get(i) + ' ');  }  System.out.println();  // Using the for each loop  for (String str : al)  System.out.print(str + ' ');  } }>

Geeks For Geeks Geeks For Geeks>

5. Ottieni elementi

// Java program to get the elemens in ArrayList import java.io.*; import java.util.*; class GFG {  public static void main (String[] args) {  ArrayList lista = nuova ArrayList();  // aggiunge il numero list.add(9);  lista.aggiungi(5);  lista.add(6);  System.out.println(lista);  // ottiene il metodo Integer n= list.get(1);  System.out.println('al numero indice 1 è:'+n);  } }>

[9, 5, 6] at indext 1 number is:5>

6. Aggiungi elementi tra due numeri

// Java program to add the elements  // between two numbers in ArrayList import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList lista = nuova ArrayList();  lista.aggiungi(1);  lista.add(2);  lista.add(4);  System.out.println(lista);  // inserisce l'elemento mancante 3 list.add(2, 3);  System.out.println(lista);  } }>

[1, 2, 4] [1, 2, 3, 4]>

7. Ordinamento di elenchi di array

// Java Program for ArrayList Sorting import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList lista = nuova ArrayList();  lista.add(2);  lista.add(4);  lista.add(3);  lista.aggiungi(1);  System.out.println('Prima di ordinare l'elenco:');  System.out.println(lista);  Collezioni.sort(lista);  System.out.println('dopo l'ordinamento dell'elenco:');  System.out.println(lista);  } }>

Before sorting list: [2, 4, 3, 1] after sorting list: [1, 2, 3, 4]>

8. Dimensione degli elementi

// Java program to find the size  // of elements of an ArrayList import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList lista = nuova ArrayList();  lista.aggiungi(1);  lista.add(2);  lista.add(3);  lista.add(4);  int b = lista.dimensione();  System.out.println('La dimensione è:' + b);  } }>

The size is :4>

Complessità di Java ArrayList

ArrayList in Java è una classe nel framework Java Collections che implementa l'interfaccia List. Ecco i vantaggi e gli svantaggi dell'utilizzo di ArrayList in Java.

Vantaggi di Java ArrayList

1. Dimensioni dinamiche: ArrayList può aumentare e ridurre dinamicamente le dimensioni, semplificando l'aggiunta o la rimozione di elementi in base alle esigenze.
2. Facile da usare: ArrayList è semplice da usare, rendendolo una scelta popolare per molti sviluppatori Java.
3. Accesso rapido: ArrayList fornisce un accesso rapido agli elementi, poiché è implementato come un array dietro le quinte.
4. Raccolta ordinata: ArrayList preserva l'ordine degli elementi, consentendoti di accedere agli elementi nell'ordine in cui sono stati aggiunti.
5. Supporta valori null: ArrayList può memorizzare valori null, rendendolo utile nei casi in cui è necessario rappresentare l'assenza di un valore.

Svantaggi di Java ArrayList

1. Più lento degli array: ArrayList è più lento degli array per alcune operazioni, come l'inserimento di elementi al centro dell'elenco.
2. Maggiore utilizzo della memoria: ArrayList richiede più memoria degli array, poiché deve mantenere le sue dimensioni dinamiche e gestire il ridimensionamento.
3. Non thread-safe: ArrayList non è thread-safe, il che significa che più thread possono accedere e modificare l'elenco contemporaneamente, causando potenziali race conditions e danneggiamento dei dati.
4. Degrado delle prestazioni: le prestazioni di ArrayList potrebbero peggiorare all'aumentare del numero di elementi nell'elenco, in particolare per operazioni come la ricerca di elementi o l'inserimento di elementi al centro dell'elenco.

Conclusione

I punti da ricordare di questo articolo sono menzionati di seguito:

• ArrayList fa parte del framework Collections. Eredita la classe AbstractList e implementa l'interfaccia List.
• ArrayList è l'implementazione di un array dinamico.
• ArrayList può essere inizializzato utilizzando diversi tipi di costruttori come senza parametri, passando la raccolta come parametro e passando l'intero come parametro.
• Le operazioni possono essere eseguite in ArrayList come segue: Aggiunta, rimozione, iterazione e ordinamento.

Domande frequenti su ArrayList

Cos'è un ArrayList in Java?

ArrayList in Java fa parte del framework Collections. Viene utilizzato per memorizzare elementi e la dimensione è ridimensionabile.

Come vengono archiviati i dati in ArrayList?

ArrayList può memorizzare dati fino a quando la dimensione dell'ArrayList è piena, dopodiché la dimensione di ArrayList viene raddoppiata se vogliamo memorizzare altri elementi.

ArrayList consente duplicati?

Sì, ArrayList consente di archiviare valori duplicati.