Iterare le collection in Java: for-each, Iterator, forEach

Un compito, più strumenti

Hai raccolto dei dati, in un ArrayList, un HashSet o una HashMap, e ora vuoi visitare ogni elemento. Java ti offre diversi modi per farlo, e la scelta dipende da tre cose: se ti serve l'indice, se devi rimuovere elementi a metà ciclo e se preferisci una sintassi a metodo o a ciclo.

La buona notizia: ogni Collection (lista, insieme, coda) supporta lo stesso ciclo for migliorato, quindi una volta imparato puoi iterarle tutte allo stesso modo.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (String lang : langs) {
            System.out.println(lang);
        }
    }
}

Leggi i due punti come "in": "per ogni lang in langs". Non tocchi mai un indice, quindi non c'è niente da sbagliare.

Il ciclo for-each

Il for migliorato è la scelta predefinita per il classico "fai qualcosa con ogni elemento". Si legge bene e funziona allo stesso modo con tutti i tipi di collection; qui con un HashSet, che non ha affatto indici:

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("urgent");
        tags.add("review");
        tags.add("urgent");   // il Set ignora il duplicato

        for (String tag : tags) {
            System.out.println(tag);
        }
    }
}

Una cosa da ricordare su un HashSet: non ha un ordine definito, quindi gli elementi possono essere stampati in qualsiasi sequenza. Il for-each li visita comunque tutti esattamente una volta.

Quando ti serve l'indice

Il for-each ti dà l'elemento ma non la sua posizione. Se ti serve davvero l'indice, per numerare le righe o per guardare gli elementi vicini, usa un ciclo con contatore insieme a size() e get(i). Funziona su una List, che è posizionale; insiemi e mappe non hanno indice, quindi questo stile non si applica a loro.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

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

Non usarlo solo per abitudine. Se non usi i per nient'altro che get(i), la versione for-each è più corta e più difficile da sbagliare.

Iterare una Map

Una Map non è una Collection, quindi non puoi usare il for-each direttamente su di essa. Scorri invece una delle sue tre viste. La più comune è entrySet(), che ti restituisce ogni coppia chiave-valore insieme:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 28);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Se ti servono solo le chiavi, scorri ages.keySet(); se ti servono solo i valori, scorri ages.values(). Preferisci entrySet() quando ti servono entrambi: scorrere le chiavi e poi chiamare ages.get(key) all'interno fa una seconda ricerca a ogni iterazione senza motivo.

L'Iterator

Il for-each è in realtà zucchero sintattico sopra un Iterator: un oggetto che percorre una collection un elemento alla volta tramite hasNext() e next(). Raramente scrivi questo ciclo a mano, con un'eccezione importante: è il modo sicuro per rimuovere elementi durante l'iterazione.

import java.util.ArrayList;
import java.util.Iterator;
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));

        Iterator<Integer> it = nums.iterator();
        while (it.hasNext()) {
            int n = it.next();
            if (n % 2 == 0) {
                it.remove();   // sicuro: rimuove l'elemento appena restituito
            }
        }

        System.out.println(nums);
    }
}

it.remove() elimina l'elemento restituito dall'ultima chiamata a next(), e l'iteratore resta valido. È l'unico modo ammesso per modificare una collection durante un ciclo manuale.

La trappola: ConcurrentModificationException

Se chiami add o remove sulla collection stessa dentro un ciclo for-each, ottieni una ConcurrentModificationException: l'iteratore si accorge che la collection è cambiata sotto di lui e si rifiuta di continuare. È uno degli errori più comuni per chi inizia.

List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4));
for (int n : nums) {
    if (n % 2 == 0) {
        nums.remove(Integer.valueOf(n));   // throws ConcurrentModificationException
    }
}

La soluzione è quasi sempre removeIf, che esprime l'intenzione in una sola riga e gestisce l'iterazione al posto tuo:

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);   // elimina i numeri pari
        System.out.println(nums);
    }
}

removeIf funziona su qualsiasi Collection, quindi la stessa chiamata ripulisce anche un HashSet.

Il metodo forEach

Ogni collection ha anche un metodo forEach che riceve una lambda e la esegue su ogni elemento. È un'alternativa al ciclo più funzionale, in stile espressione, comoda per brevi istruzioni di una riga:

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");
        langs.forEach(lang -> System.out.println(lang));

        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 28);
        ages.forEach((name, age) -> System.out.println(name + ": " + age));
    }
}

Nota che Map.forEach riceve direttamente una lambda a due argomenti (key, value), senza bisogno di entrySet(). Usa forEach per effetti collaterali rapidi; torna al normale ciclo for quando il corpo cresce o devi uscire in anticipo con break, cosa che una lambda non può fare.

Prossimo argomento: i metodi

Ora hai raccolto dati nelle collection e li hai percorsi in tutti i modi che Java offre. Il passo successivo è raccogliere il comportamento: scrivere i tuoi metodi per dare un nome a un blocco di logica, passargli degli input e riutilizzarlo. È l'argomento della pagina successiva.