«Array infinito» — ArrayList<T>

1. Introduzione

Questa è la prima lezione del livello bonus. Siamo già molto vicini a studiare l’OOP. E voglio stuzzicare il tuo interesse e anticipare un po’ 😈. In questo livello ti parlerò di 5 cose interessanti:

1. ♾️ Imparerai a creare array infiniti
2. 📖 Poi a mantenere un «dizionario personale»
3. 💾 Dopodiché ti introdurrò brevemente al lavoro con i file
4. 🌐 Poi impareremo a scaricare immagini da Internet
5. 🛰️ E nell’ultima lezione del livello seguirai in tempo reale la stazione spaziale ISS

Come funziona tutto questo «sotto il cofano» lo scoprirai nei prossimi livelli, ma oggi imparerai semplicemente a usare gli strumenti che ti metto a disposizione. Ti ho incuriosito? Allora iniziamo 😇.

Ripassiamo gli array normali

Ripassiamo un array normale in Java:

int[] arr = new int[10];

È una cosa ottima, ma ha un paio di limitazioni: la dimensione è fissa, non si possono aggiungere o rimuovere elementi senza creare un nuovo array. E a volte vorremmo un array che cresca e si riduca all’occorrenza. E abbiamo un’ottima soluzione — l’array dinamico ArrayList!

ArrayList è un «array intelligente» che può crescere e ridursi automaticamente. A differenza di un array normale, in cui la dimensione è fissa, ArrayList si occupa da solo di avere spazio sufficiente per i nuovi elementi.

Creiamo un array infinito

Per creare il nostro ArrayList, bisogna scrivere un codice del tipo:

ArrayList<String> array = new ArrayList<String>()

Dopo di ciò è possibile aggiungere elementi:

array.add("Masha");
array.add("Katya");

Creiamo un array dinamico per numeri interi

Come forse avrai già intuito, il tipo degli elementi del nostro array dinamico va indicato tra parentesi angolari. Si può indicare qualsiasi tipo, tranne i tipi primitivi. I tipi primitivi vanno sostituiti con i rispettivi tipi‑wrapper.

Esempio:

ArrayList<Integer> numbers = new ArrayList<Integer>();      // int
ArrayList<Double> fees = new ArrayList<Double>();            // double
ArrayList<Boolean> yesList = new ArrayList<Boolean>();       // boolean
ArrayList<Character> chars = new ArrayList<Character>();     // char

Il nostro ArrayList non supporta [index] per l’accesso agli elementi, ma ha metodi specifici che coprono tutte le tue esigenze. Vediamo i più interessanti.

2. Metodo add(element) — aggiunta di un elemento

La prima cosa che facciamo con una lista è aggiungere dati. Per questo serve il metodo add. Aggiunge l’elemento in coda alla lista.

ArrayList<String> todo = new ArrayList<>(); // elenco di cose da fare
todo.add("Imparare ArrayList");
todo.add("Preparare il tè");
todo.add("Fare una passeggiata");

Dopo queste tre righe abbiamo una lista di tre stringhe. A differenza dell’array, non serve indicare prima la dimensione — cresce da sola man mano che aggiungiamo elementi.

Molto comodo: si può partire da una lista vuota e riempirla gradualmente in base alle azioni dell’utente o ai dati in ingresso del programma.

3. Metodo get(index) — accesso per indice

Ogni elemento della lista ha il proprio numero d’ordine — indice. L’indicizzazione parte sempre da zero. Cioè il primo elemento ha numero 0, il secondo 1 e così via.

Se vogliamo ottenere un elemento per numero, usiamo il metodo get.

String task = todo.get(1);
System.out.println("Seconda cosa da fare: " + task);

Output:

Seconda cosa da fare: Preparare il tè

È importante ricordare: se accedi a un indice che non esiste (per esempio, todo.get(10) con una lista di tre elementi), il programma lancerà l’errore IndexOutOfBoundsException. Quindi conviene essere sicuri dell’indice oppure controllare la dimensione della lista tramite size().

4. Metodo set(index, element) — sostituzione di un elemento

Capita di dover sostituire un elemento nella lista. In tal caso non serve eliminare e aggiungere di nuovo — basta usare il metodo set.

todo.set(1, "Preparare il caffè"); 
System.out.println("Ora la seconda cosa da fare: " + todo.get(1));

Output:

Ora la seconda cosa da fare: Preparare il caffè

Quindi, set è un modo per aggiornare la lista «al volo».

5. Metodo remove(index) — rimozione di un elemento

È possibile rimuovere un elemento da ArrayList per indice.

todo.remove(0); 
System.out.println("La prima cosa da fare ora: " + todo.get(0));

Output:

La prima cosa da fare ora: Preparare il caffè

Abbiamo rimosso il primo elemento (indice 0). E ora il secondo è diventato il primo, e come secondo è passato quello che prima era il terzo. Punto importante: dopo la rimozione gli elementi della lista si spostano.

Questo a volte può sorprendere i principianti. Ricorda sempre che dopo la rimozione gli indici vengono ricalcolati.

6. Metodo size() — ottenere la dimensione della lista

Il metodo size restituisce il numero di elementi nella lista. È simile alla proprietà length degli array, ma in ArrayList — è un metodo.

System.out.println("Totale cose da fare: " + todo.size());

Output:

Totale cose da fare: 2

Spesso size viene usato nei cicli per iterare tutti gli elementi:

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

7. Metodo contains(element) — verifica di presenza

Per sapere se un elemento è presente nella lista, si può usare contains. Questo metodo restituisce true o false.

System.out.println(todo.contains("Fare una passeggiata"));
System.out.println(todo.contains("Preparare il tè"));

Output:

true
false

Metodo molto utile quando vuoi evitare duplicati o verificare la condizione «esiste un elemento del genere nella lista».

8. Iterazione degli elementi

Ci sono due modi per attraversare la lista.

Ciclo indicizzato

Questo approccio è utile se ti serve il numero dell’elemento.

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

Ciclo for-each

Se il numero non serve e vuoi solo vedere tutti gli elementi — usa il ciclo for-each.

for (String task : todo) 
{
    System.out.println("Cosa da fare: " + task);
}

Questo tipo di ciclo è più corto e più leggibile.

9. Pratica: ArrayList nella tua applicazione

Facciamo una lista di cose da fare che si possa popolare e stampare:

import java.util.ArrayList;
import java.util.Scanner;

public class TodoApp 
{
    public static void main(String[] args) 
    {
        ArrayList<String> todo = new ArrayList<>();
        Scanner console = new Scanner(System.in);

        while (true) 
        {
            System.out.print("Inserisci una cosa da fare (o una riga vuota per uscire): ");
            String task = console.nextLine();
            if (task.isEmpty()) break;
            todo.add(task);
        }

        System.out.println("Il tuo elenco di cose da fare:");
        for (int i = 0; i < todo.size(); i++) 
        {
            System.out.println((i + 1) + ". " + todo.get(i));
        }
    }
}

Spero che ti sia piaciuto il nostro array infinito. È la prima delle collezioni Java con cui hai fatto conoscenza. Penso che anche le altre ti piaceranno.