Menu

Java ArrayList - Come dichiarare, inizializzare e stampare un ArrayList

  • Principale
  • Altro
  • Java ArrayList - Come dichiarare, inizializzare e stampare un ArrayList

java arraylist how declare

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial spiega come dichiarare, inizializzare e stampare Java ArrayList con esempi di codice. Imparerai anche su 2D Arraylist e implementazione di ArrayList in Java:

Java Collections Framework e l'interfaccia List sono stati spiegati in dettaglio nei nostri tutorial precedenti. ArrayList è una struttura dati che fa parte di Collections Framework e può essere vista come simile a array e vettori.

ArrayList può essere percepito come un array dinamico che ti consente di aggiungere o rimuovere elementi da esso in qualsiasi momento o semplicemente detto, dinamicamente.

=> Dai un'occhiata alla guida per principianti di Java qui.

ArrayList in Java

In altre parole, la sua dimensione può aumentare o diminuire dinamicamente a differenza degli array la cui dimensione rimane statica una volta dichiarata.

Cosa imparerai:

Classe ArrayList in Java

La struttura dati ArrayList in Java è rappresentata dalla classe ArrayList che fa parte del ' java.util 'Pacchetto.

La gerarchia per la classe ArrayList è mostrata di seguito.

Gerarchia per la classe ArrayList

Come puoi vedere, la classe ArrayList implementa l'interfaccia List che a sua volta si estende dall'interfaccia Collection.

Di seguito viene fornita la definizione generale della classe ArrayList:

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

Ecco alcune delle caratteristiche distintive di ArrayList:

  • La classe ArrayList di Java memorizza gli elementi mantenendo l'ordine di inserimento.
  • ArrayList consente di archiviare elementi duplicati in esso.
  • ArrayList non è sincronizzato, il punto principale che differenzia la classe ArrayList dalla classe Vector in Java.
  • ArrayList in Java è più identico a Vectors in C ++.
  • ArrayList in Java utilizza anche indici come array e supporta l'accesso casuale.
  • Le operazioni che manipolano gli elementi in ArrayList sono lente in quanto è necessario eseguire molti spostamenti di elementi se si desidera rimuovere qualsiasi elemento da ArrayList.
  • La classe ArrayList non può contenere tipi primitivi ma solo oggetti. In questo caso, di solito lo chiamiamo 'ArrayList of objects'. Quindi, se vuoi memorizzare il tipo intero di elementi, allora devi usare l'oggetto Integer della classe wrapper e non il tipo primitivo int.

Crea e dichiara ArrayList

Per poter utilizzare la classe ArrayList nel tuo programma, devi prima includerla nel tuo programma utilizzando la direttiva 'import' come mostrato di seguito:

import java.util.ArrayList;

O

import java.util.*; //this will include all classes from java.util package

Dopo aver importato la classe ArrayList nel programma, è possibile creare un oggetto ArrayList.

La sintassi generale per la creazione di ArrayList è:

ArrayList arrayList = new ArrayList ();

Oltre all'istruzione precedente che utilizza il costruttore predefinito, la classe ArrayList fornisce anche altri costruttori sovraccaricati che è possibile utilizzare per creare ArrayList.

Metodi del costruttore

La classe ArrayList in Java fornisce i seguenti metodi di costruzione per creare ArrayList.

Metodo n. 1: ArrayList ()

Questo metodo utilizza il costruttore predefinito della classe ArrayList e viene utilizzato per creare un ArrayList vuoto.

La sintassi generale di questo metodo è:

ArrayList list_name = new ArrayList();

Per esempio, è possibile creare un ArrayList generico di tipo String utilizzando la seguente istruzione.

ArrayList arraylist = new ArrayList();

Questo creerà un ArrayList vuoto denominato 'arraylist' di tipo String.

Metodo n. 2: ArrayList (capacità int)

Questo costruttore sovraccarico può essere usato per creare un ArrayList con le dimensioni o la capacità specificate fornite come argomento al costruttore.

La sintassi generale per questo metodo è:

ArrayList list_name = new ArrayList(int capacity);

Esempio:

ArrayList arraylist = new ArrayList(10);

L'istruzione precedente crea un ArrayList vuoto denominato 'arraylist' di tipo Integer con capacità 10.

Metodo n. 3: ArrayList (raccolta c)

Il terzo costruttore sovraccaricato per la classe ArrayList accetta una raccolta già esistente come argomento e crea un ArrayList con gli elementi della raccolta specificata c come elementi iniziali.

La sintassi generale per l'inizializzazione di ArrayList utilizzando questo costruttore è:

ArrayList list_name = new ArrayList (Collection c)

Per esempio, se intList è una raccolta esistente con elementi {10,20,30,40,50}, la seguente istruzione creerà un elenco 'arraylist' con il contenuto di intList come suoi elementi iniziali.

ArrayList ArrayList = new ArrayList(intList);

La classe ArrayList supporta anche vari metodi che possono essere utilizzati per manipolare il contenuto dell'elenco. Discuteremo questi metodi in dettaglio nel nostro prossimo tutorial 'Metodi ArrayList in Java'.

Inizializza ArrayList in Java

Una volta creato ArrayList, esistono diversi modi per inizializzare ArrayList con valori. In questa sezione, discuteremo questi modi.

# 1) Utilizzo di Arrays.asList

Qui è possibile passare un Array convertito in List utilizzando il metodo asList della classe Array per inizializzare ArrayList.

Sintassi generale:

ArrayList arrayListName = new ArrayList( Arrays.asList (Object o1, Object o2, …, Object on));

Esempio:

import java.util.*; public class Main { public static void main(String args()) { //create and initialize ArrayList object myList with Arrays.asList method ArrayList myList = new ArrayList( Arrays.asList('One', 'Two', 'Three')); //print the ArrayList System.out.println('List contents:'+myList); } }

Produzione:

Inizializza ArrayList in Java

# 2) Utilizzo del metodo della classe interna anonimo

Qui usiamo la classe interna anonima per inizializzare ArrayList su valori.

La sintassi generale per l'utilizzo di una classe interna anonima per l'inizializzazione di ArrayList è la seguente:

ArrayListarraylistName = new ArrayList(){{ add(Object o1); add (Object o2);… add (Object on);}};

Esempio:

import java.util.*; public class Main { public static void main(String args()) { //create and initialize ArrayList with anonymous inner class calls ArrayList colors = new ArrayList(){{ add('Red'); add('Blue'); add('Purple'); }}; //print the ArrayList System.out.println('Content of ArrayList:'+colors); } }

Produzione:

Utilizzo del metodo della classe interna anonimo

# 3) Utilizzo del metodo add

Questo è il metodo comune per aggiungere elementi a qualsiasi raccolta.

La sintassi generale per l'utilizzo del metodo add per aggiungere elementi a ArrayList è:

ArrayListArraylistName = new ArrayList(); ArraylistName.add(value1); ArraylistName.add(value2); ArraylistName.add(value3);

Esempio di programmazione:

import java.util.*; public class Main { public static void main(String args()) { //create ArrayList ArrayList colors = new ArrayList(); //add elements to the ArrayList using add method colors.add('Red'); colors.add('Green'); colors.add('Blue'); colors.add('Orange'); //print the ArrayList System.out.println('Content of ArrayList:'+colors); }

Produzione:

Utilizzo del metodo add

# 4) Utilizzo del metodo Collection.nCopies

Questo metodo viene utilizzato per inizializzare ArrayList con gli stessi valori. Forniamo il conteggio degli elementi da inizializzare e il valore iniziale del metodo.

La sintassi generale dell'inizializzazione è:

ArrayList arrayListName = new ArrayList(Collections.nCopies(count, element));

L'esempio seguente mostra l'inizializzazione dell'array utilizzando il metodo Collections.nCopies.

import java.util.*; public class Main { public static void main(String args()) { //create ArrayList with 10 elements //initialized to value 10 using Collections.nCopies ArrayList intList = new ArrayList(Collections.nCopies(10,10)); //print the ArrayList System.out.println('Content of ArrayList:'+intList); } }

Produzione:

Utilizzando il metodo Collection.nCopies

Iterazione attraverso ArrayList

Abbiamo i seguenti modi per attraversare o eseguire il loop attraverso ArrayList:

  1. Utilizzo del ciclo for
  2. Per ciclo for-each (ciclo for migliorato).
  3. Utilizzo dell'interfaccia Iterator.
  4. Dall'interfaccia ListIterator.
  5. Con il metodo forEachRemaining ().

In effetti, questi metodi vengono utilizzati per scorrere le raccolte in generale. Vedremo esempi di ciascuno dei metodi rispetto ad ArrayList in questo tutorial.

# 1) Utilizzo del ciclo for

Un ciclo for basato su indice può essere utilizzato per attraversare ArrayList e stampare i suoi elementi.

Di seguito è riportato un esempio per attraversare e stampare ArrayList utilizzando il ciclo for.

import java.util.*; public class Main { public static void main(String() args) { //create a list List intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using for-loop:'); //use for loop to traverse through its elements and print it for(int i=0;i

Produzione:

Con il metodo forEachRemaining ()

Questo è il modo più semplice e facile per attraversare e stampare gli elementi di ArrayList e funziona allo stesso modo anche in caso di altre raccolte.

# 2) Per ciclo for-each (migliorato per ciclo)

Puoi anche attraversare ArrayList utilizzando un ciclo for-each o il ciclo for migliorato. Prima di Java 8, non includeva espressioni lambda. Ma da Java 8 in poi, puoi anche includere espressioni Lambda nel ciclo for-each.

Il programma seguente mostra l'attraversamento e la stampa di ArrayList utilizzando per ogni ciclo ed espressione lambda.

import java.util.*; public class Main { public static void main(String() args) { //create a list List intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using for-each loop:'); //use for-each loop to traverse through its elements and print it intList.forEach(val ->{ System.out.print(val + ' '); }); } }

Produzione:

Per ogni ciclo

# 3) Utilizzo dell'interfaccia Iterator

Abbiamo visto l'interfaccia di Iterator in dettaglio nei nostri argomenti precedenti. L'interfaccia Iterator può essere utilizzata per iterare attraverso ArrayList e stamparne i valori.

Il seguente programma lo mostra.

import java.util.*; public class Main { public static void main(String() args) { //create a list List intList = new ArrayList(); intList.add(5); intList.add(10); intList.add(15); intList.add(20); intList.add(25); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using Iterator interface:'); //Traverse through the ArrayList using iterator Iterator iter=arraylist.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } } }

Produzione:

Utilizzando l

# 4) Per interfaccia ListIterator

Puoi anche attraversare ArrayList utilizzando ListIterator. ListIterator può essere utilizzato per attraversare ArrayList in avanti e indietro.

Implementiamo un programma Java che dimostri un esempio di utilizzo di ListIterator.

import java.util.*; class Main{ public static void main(String args()){ //create a list and initiliaze it List colors_list=new ArrayList();//Creating arraylist colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); colors_list.add('Cyan'); colors_list.add('Magenta'); colors_list.add('Yellow'); System.out.println('The contents of the list using ListIterator:'); //Traverse the list using ListIterator ListIterator color_iter=colors_list.listIterator(colors_list.size()); while(color_iter.hasPrevious()) { String str=color_iter.previous(); System.out.print(str + ' '); } } }

Produzione:

Dall

Come puoi vedere dall'output, nel programma sopra ArrayList viene attraversato all'indietro usando i metodi hasPrevious () e previous () di ListIterator.

# 5) Con il metodo forEachRemaining ()

Questo è uno dei metodi per attraversare ArrayList ed è disponibile da Java 8.

Il seguente programma mostra il metodo forEachRemaining () per attraversare ArrayList.

import java.util.*; class Main{ public static void main(String args()){ //create a list and initiliaze it List colors_list=new ArrayList(); colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); colors_list.add('Cyan'); colors_list.add('Magenta'); colors_list.add('Yellow'); System.out.println('The contents of the list using forEachRemaining() method:'); //Traverse the list using forEachRemaining () method Iterator itr=colors_list.iterator(); itr.forEachRemaining(val-> //lambda expression { System.out.print(val + ' '); }); } }

Produzione:

Con il metodo forEachRemaining ()

come creare un nuovo progetto java in eclipse

Usiamo il metodo forEachRemaining () insieme a un Iterator. È simile a ciascuno e usiamo l'espressione lambda all'interno di questo metodo.

ArrayList Java Esempio

In questa sezione, vedremo l'implementazione di ArrayList in Java. Ad esempio, implementeremo un esempio completo dalla creazione, inizializzazione e utilizzo di Java ArrayList per eseguire varie manipolazioni.

import java.util.ArrayList; class Main { public static void main(String() args) { //Creating a generic ArrayList ArrayList newList = new ArrayList(); //Size of arrayList System.out.println('Original size of ArrayList at creation: ' + newList.size()); //add elements to it newList.add('IND'); newList.add('USA'); newList.add('AUS'); newList.add('UK'); //print the size after adding elements System.out.println('ArrayList size after adding elements: ' + newList.size()); //Print ArrayList contents System.out.println('Contents of the ArrayList: ' + newList); //Remove an element from the list newList.remove('USA'); System.out.println('ArrayList contents after removing element(USA): ' + newList); //Remove another element by index newList.remove(2); System.out.println('ArrayList contents after removing element at index 2: ' + newList); //print new size System.out.println('Size of arrayList: ' + newList.size()); //print list contents System.out.println('Final ArrayList Contents: ' + newList); } }

Produzione:

Esempio java di ArrayList

ArrayList bidimensionale in Java

Sappiamo che un ArrayList non ha dimensioni come Array. Ma possiamo avere ArrayList annidati che sono anche chiamati '2D ArrayLists' o 'ArrayList of ArrayLists'.

La semplice idea alla base di questi ArrayList annidati è che, dato un ArrayList, ogni elemento di questo ArrayList è un altro ArrayList.

Facci capire questo utilizzando il seguente programma.

import java.util.*; public class Main { public static void main(String() args) { int num = 3; // declare an arrayList of ArrayLists or 2D ArrayList ArrayList intList = new ArrayList (num); // Create individual elements or ArrayLists and add them to intList as elements ArrayList list_elem1 = new ArrayList(); list_elem1.add(10); intList.add(list_elem1); ArrayList list_elem2 = new ArrayList(); list_elem2.add(20); list_elem2.add(30); intList.add(list_elem2); ArrayList list_elem3 = new (); list_elem3.add(40); list_elem3.add(50); list_elem3.add(60); intList.add(list_elem3); System.out.println('Contents of 2D ArrayList(Nested ArrayList):'); //print the 2D ArrayList or nested ArrayList for (int i = 0; i

Produzione:

ArrayList bidimensionale inJava

Il programma sopra mostra 2D ArrayList. In primo luogo, dichiariamo un ArrayList di ArrayLists. Quindi definiamo singoli ArrayList che serviranno come singoli elementi di ArrayList annidati quando aggiungiamo ciascuno di questi ArrayList a Nested ArrayList.

Per accedere a ogni elemento di ArrayList, dobbiamo chiamare il metodo get due volte. Prima per accedere alla riga di Nested ArrayList e quindi per accedere alla singola intersezione di riga e colonna.

Notare che è possibile aumentare i livelli annidati di ArrayList per definire ArrayList multidimensionali. Per esempio, 3D ArrayList avrà come elementi 2D ArrayList e così via.

Domande frequenti

D # 1) Cos'è ArrayList in Java?

Risposta: Un ArrayList in Java è un array dinamico. È ridimensionabile in natura, ovvero aumenta di dimensioni quando vengono aggiunti nuovi elementi e si restringe quando gli elementi vengono eliminati.

D # 2) Qual è la differenza tra Array e ArrayList?

Risposta: Un array è in struttura statica e la sua dimensione non può essere modificata una volta dichiarata. Un ArrayList è un array dinamico e cambia la sua dimensione quando gli elementi vengono aggiunti o rimossi.

L'array è una struttura di base in Java mentre un ArrayList è una parte del Collection Framework in Java. Un'altra differenza è che mentre Array utilizza l'indice (()) per accedere agli elementi, ArrayList utilizza metodi per accedere ai suoi elementi.

D # 3) ArrayList è un elenco?

Risposta: ArrayList è un sottotipo dell'elenco. ArrayList è una classe mentre List è un'interfaccia.

D # 4) ArrayList è una raccolta?

Risposta: No. ArrayList è un'implementazione di Collection che è un'interfaccia.

D # 5) In che modo ArrayList aumenta le sue dimensioni?

Risposta: Internamente ArrayList è implementato come Array. ArrayList ha un parametro size. Quando gli elementi vengono aggiunti a ArrayList e viene raggiunto il valore della dimensione, ArrayList aggiunge internamente un altro array per accogliere nuovi elementi.

Conclusione

Questo era il tutorial sulle basi della classe ArrayList in Java. Abbiamo visto la creazione e l'inizializzazione della classe ArrayList insieme a un'implementazione dettagliata della programmazione di ArrayList.

Abbiamo anche discusso degli ArrayList 2D e multidimensionali. La classe ArrayList supporta i vari metodi che possiamo utilizzare per manipolare gli elementi. Nei nostri prossimi tutorial riprenderemo questi metodi.

=> Leggere attraverso la serie di formazione Easy Java.

Lettura consigliata

^