ArrayList in Java: come creare e utilizzare una lista

ArrayList è una delle strutture dati utilizzate più spesso in Java. La struttura consente il cambiamento dinamico e il salvataggio di una raccolta di oggetti. In questo tutorial ti spieghiamo la sintassi e i metodi degli ArrayList in Java.

Qual è la differenza fra ArrayList e array in Java?

ArrayList in Java ha dimensioni dinamiche, ossia è possibile aggiungere o rimuovere gli elementi con facilità. Inoltre, la classe ArrayList fa parte del Java Collections Framework e non è disponibile 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 salvataggio di oggetti, le operazioni di ricerca o ordinamento di dati e la creazione di liste o code di attesa.

Al contrario, con il tipo di dati array non è possibile modificare le dimensioni. Pertanto, il numero di oggetti da includere nell’array deve essere già noto in precedenza. Gli array sono quindi adatti alla gestione di una quantità predefinita di tipi di dati primitivi, come int, float, char o boolean.

Uno svantaggio 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 è frammentata. Per questo motivo è importante tenere conto dei rispettivi vantaggi e svantaggi e scegliere la struttura dati giusta per il rispettivo caso applicativo.

La sintassi di ArrayList in Java

Prima di creare un ArrayList è necessario 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.

Successivamente passiamo a creare le liste del tipo String e Integer.

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

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

Gli ArrayList utilizzano 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 operazioni come l’aggiunta o la rimozione di elementi non vengono eseguite tramite operatori Java, ma con metodi predefiniti. Nelle parti seguenti ti mostriamo i metodi più diffusi con gli ArrayList.

Aggiunta di elementi

Dopo aver creato l’ArrayList “colors” di tipo String, utilizziamo il metodo .add() per aggiungere 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, utilizziamo il metodo .remove() con indicazione 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 modificato e l’elemento rimosso:

ArrayList: [blue, green]
Removed Element: red

Come nella maggior parte dei linguaggi di programmazione, 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]

Determinazione della lunghezza dell’ArrayList in Java

La quantità di elementi in un ArrayList è facilmente calcolabile 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

Ordinamento e iterazione in un ArrayList

Per ordinare un ArrayList in Java è necessario importare la classe Collections. Per l’iterazione utilizziamo un ciclo for-each in Java. Per ogni iterazione 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 restituiti in ordine crescente:

9
17
20
54