ArrayList in Java: creare, aggiungere, rimuovere, scorrere e ordinare

Una lista che si ridimensiona da sola

Un array Java semplice ha una lunghezza fissa: se scegli dieci posizioni, avrai dieci posizioni per sempre. ArrayList è l'alternativa ridimensionabile di java.util: cresce quando aggiungi, si riduce quando rimuovi e offre metodi comodi per le operazioni che fai davvero con una lista.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Ada");
        names.add("Boris");
        names.add("Chen");

        System.out.println(names);
        System.out.println("Count: " + names.size());
    }
}

Nota il tipo tra parentesi angolari, List<String>, che dice al compilatore che la lista contiene valori String. Il <> (il "diamond") a destra permette a Java di dedurre lo stesso tipo senza ripeterlo. E nota che devi importare java.util.ArrayList: non è disponibile di default.

Dichiara come List, costruisci come ArrayList

Vedrai quasi sempre la variabile dichiarata con l'interfaccia List invece che con la classe concreta ArrayList:

List<String> names = new ArrayList<>();

È una buona abitudine, non una regola. Programmare sull'interfaccia List significa che il resto del codice non si preoccupa di quale implementazione di lista hai usato, quindi in seguito puoi sostituirla con un'altra senza toccarlo. Nell'uso quotidiano le due si comportano allo stesso modo.

Aggiungere, leggere e modificare

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");      // aggiunge in fondo
        fruits.add("banana");
        fruits.add(1, "cherry");  // inserisce all'indice 1

        System.out.println(fruits.get(0));   // legge per indice
        fruits.set(0, "apricot");            // sovrascrive l'indice 0

        System.out.println(fruits);
    }
}

• add(value) aggiunge in fondo.
• add(index, value) inserisce in una posizione, spostando in avanti gli elementi successivi.
• get(index) legge l'elemento in una posizione (a partire da zero).
• set(index, value) sovrascrive un elemento esistente.

Gli indici partono da zero, e get con un indice fuori intervallo lancia IndexOutOfBoundsException.

Rimuovere elementi

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("cherry");

        fruits.remove("banana");  // rimuove per valore (prima corrispondenza)
        fruits.remove(0);         // rimuove per indice

        System.out.println(fruits);
    }
}

C'è una trappola classica quando la lista contiene Integer. remove(int) significa "rimuovi per indice" e remove(Object) significa "rimuovi per valore", quindi:

List<Integer> nums = new ArrayList<>(List.of(10, 20, 30));
nums.remove(1);                      // rimuove l'indice 1 -> il valore 20
nums.remove(Integer.valueOf(20));    // rimuove il valore 20

Avvolgi il valore in Integer.valueOf(...) quando intendi "rimuovi questo valore" e non "rimuovi questo indice".

Dimensione, contains e ricerca dell'indice

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        System.out.println(fruits.size());            // 3
        System.out.println(fruits.isEmpty());         // false
        System.out.println(fruits.contains("banana")); // true
        System.out.println(fruits.indexOf("cherry"));  // 2
    }
}

List.of(...) crea al volo una lista immutabile; passarla al costruttore di ArrayList ti dà una copia modificabile che parte con quei valori.

Scorrere un ArrayList

Il ciclo più pulito è il for migliorato (il ciclo for-each):

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (String fruit : fruits) {
            System.out.println(fruit.toUpperCase());
        }
    }
}

Quando ti serve anche l'indice, usa un ciclo con contatore insieme a size() e get(i):

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (int i = 0; i < fruits.size(); i++) {
            System.out.println(i + ": " + fruits.get(i));
        }
    }
}

Una regola: non aggiungere né rimuovere elementi da una lista mentre un ciclo for-each la sta scorrendo, perché viene lanciata una ConcurrentModificationException. Per eliminare in sicurezza gli elementi che corrispondono a una condizione, usa removeIf:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);   // scarta i numeri pari
        System.out.println(nums);
    }
}

Ordinare

Collections.sort ordina una lista sul posto usando l'ordine naturale (alfabetico per le stringhe, numerico per i numeri):

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(3, 1, 4, 1, 5, 9, 2, 6));

        Collections.sort(nums);
        System.out.println(nums);

        nums.sort(Collections.reverseOrder());  // decrescente
        System.out.println(nums);
    }
}

Per ordinamenti personalizzati, passa un Comparator a list.sort(...), per esempio names.sort(Comparator.comparingInt(String::length)) per ordinare per lunghezza.

ArrayList contiene oggetti, non primitivi

Non puoi scrivere ArrayList<int>. I generics funzionano solo con tipi oggetto, quindi usa la classe wrapper Integer, Double, Boolean e così via:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> scores = new ArrayList<>();
        scores.add(95);   // l'int 95 viene convertito in Integer (autoboxing)
        scores.add(88);

        int first = scores.get(0);  // riconvertito in int (unboxing)
        System.out.println(first + scores.get(1));
    }
}

L'autoboxing di Java converte per te tra int e Integer, quindi il codice si legge in modo naturale: ricorda solo che la lista in sé memorizza oggetti Integer.

Prossimo passo: HashMap

ArrayList è lo strumento giusto quando ti interessano ordine e posizione. Quando devi cercare qualcosa tramite una chiave, come un nome utente per trovare un utente o un codice prodotto per trovare un prezzo, ti serve una HashMap, che è la prossima pagina.