ArrayList in Java: come creare e uti­liz­za­re una lista

ArrayList è una delle strutture dati uti­liz­za­te più spesso in Java. La struttura consente il cam­bia­men­to dinamico e il sal­va­tag­gio di una raccolta di oggetti. In questo tutorial ti spie­ghia­mo la sintassi e i metodi degli ArrayList in Java.

Qual è la dif­fe­ren­za fra ArrayList e array in Java?

ArrayList in Java ha di­men­sio­ni dinamiche, ossia è possibile ag­giun­ge­re o rimuovere gli elementi con facilità. Inoltre, la classe ArrayList fa parte del Java Col­lec­tions Framework e non è di­spo­ni­bi­le a livello nativo, al contrario degli array, ma deve essere importata dalla libreria java.util.

Gli ArrayList sono una scelta valida nei casi in cui la lunghezza della lista Java può variare. Alcuni esempi sono il sal­va­tag­gio di oggetti, le ope­ra­zio­ni di ricerca o or­di­na­men­to di dati e la creazione di liste o code di attesa.

Al contrario, con il tipo di dati array non è possibile mo­di­fi­ca­re le di­men­sio­ni. Pertanto, il numero di oggetti da includere nell’array deve essere già noto in pre­ce­den­za. Gli array sono quindi adatti alla gestione di una quantità pre­de­fi­ni­ta di tipi di dati primitivi, come int, float, char o boolean.

Uno svan­tag­gio degli ArrayList è il tempo di accesso più lungo. Mentre con gli array è presente un’area di memoria fissa e riservata, nel caso degli ArrayList la memoria è fram­men­ta­ta. Per questo motivo è im­por­tan­te tenere conto dei ri­spet­ti­vi vantaggi e svantaggi e scegliere la struttura dati giusta per il ri­spet­ti­vo caso ap­pli­ca­ti­vo.

La sintassi di ArrayList in Java

Prima di creare un ArrayList è ne­ces­sa­rio importare la relativa classe dalla libreria java.util.

import java.util.ArrayList;

La sintassi generale è la seguente:

ArrayList<Type> arrayList= new ArrayList<>();

Qui “Type” sta per il tipo di dati in questione dell’ArrayList in Java.

Suc­ces­si­va­men­te passiamo a creare le liste del tipo String e Integer.

ArrayList<String> arrayList= new ArrayList<>();

ArrayList<Integer> arrayList= new ArrayList<>();

Gli ArrayList uti­liz­za­no l’apposita classe Wrapper di tipi di dati primitivi in modo da gestirli come oggetti. Pertanto, dobbiamo indicare Integer anziché int.

Esempi di metodi con ArrayList in Java

Nel caso degli ArrayList, le ope­ra­zio­ni come l’aggiunta o la rimozione di elementi non vengono eseguite tramite operatori Java, ma con metodi pre­de­fi­ni­ti. Nelle parti seguenti ti mostriamo i metodi più diffusi con gli ArrayList.

Aggiunta di elementi

Dopo aver creato l’ArrayList “colors” di tipo String, uti­liz­zia­mo il metodo .add() per ag­giun­ge­re vari elementi.

import java.util.ArrayList;
class Main {
    public static void main(String[] args){
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println("ArrayList: " + colors);
    }
}

Il risultato è il seguente:

ArrayList: [blue, red, green]

Rimozione di elementi

Per rimuovere oggetti da un ArrayList in Java, uti­liz­zia­mo il metodo .remove() con in­di­ca­zio­ne dell’indice dell’elemento.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println("ArrayList: " + colors);
        String color = colors.remove(1);
        System.out.println("ArrayList: " + colors);
        System.out.println("Removed Element: " + color);
    }
}

Il risultato mostra l’ArrayList mo­di­fi­ca­to e l’elemento rimosso:

ArrayList: [blue, green]
Removed Element: red

Come nella maggior parte dei linguaggi di pro­gram­ma­zio­ne, anche in Java il conteggio parte dalla posizione 0. Pertanto, l’elemento rimosso è quello con l’indice 1 red.

Accesso agli elementi di un ArrayList in Java

Con la funzione .get() è possibile accedere a un elemento in una data posizione.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> clothes = new ArrayList<>();
        clothes.add("jacket");
        clothes.add("shirt");
        clothes.add("pullover");
        System.out.println("ArrayList: " + clothes);
        String str = clothes.get(2);
        System.out.print("Element at index 2: " + str);
    }
}

Come risultato otteniamo:

ArrayList: [jacket, shirt, pullover]
Element at index 2: pullover

Modifica di elementi

Con .set() è possibile definire un nuovo elemento per un indice specifico.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println("ArrayList: " + colors);
        colors.set(2, "yellow");
        System.out.println("Modified ArrayList: " + colors);
    }
}

Come risultato troviamo ora yellow anziché green all’indice 2:

ArrayList: [blue, red, green]
Modified ArrayList: [blue, red, yellow]

De­ter­mi­na­zio­ne della lunghezza dell’ArrayList in Java

La quantità di elementi in un ArrayList è fa­cil­men­te cal­co­la­bi­le con il metodo .size().

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println(colors.size());
    }
}

Il risultato che otteniamo è il seguente:

3

Or­di­na­men­to e ite­ra­zio­ne in un ArrayList

Per ordinare un ArrayList in Java è ne­ces­sa­rio importare la classe Col­lec­tions. Per l’ite­ra­zio­ne uti­liz­zia­mo un ciclo for-each in Java. Per ogni ite­ra­zio­ne del ciclo, il relativo elemento viene emesso sulla console.

import java.util.ArrayList;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> ages = new ArrayList<Integer>();
        ages.add(20);
        ages.add(54);
        ages.add(17);
        ages.add(9);
        Collections.sort(ages);
        for (int i : ages) {
            System.out.println(i);
        }
    }
}

Gli elementi dell’ArrayList vengono re­sti­tui­ti in ordine crescente:

9
17
20
54