Ciclo for in Java: sintassi, esempi e il for-each migliorato

Il classico ciclo for in tre parti

Un ciclo for ripete un blocco un numero controllato di volte. La forma di Java racchiude tre elementi tra le parentesi, separati da punto e virgola:

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

Le tre parti vengono eseguite con un ritmo fisso:

1. Inizializzazione (int i = 0): viene eseguita una volta, prima di tutto il resto.
2. Condizione (i < 5): viene controllata prima di ogni passaggio; il ciclo si ferma quando è falsa.
3. Aggiornamento (i++): viene eseguito dopo ogni passaggio, prima di ricontrollare la condizione.

Quindi questo stampa da i = 0 a i = 4. Il contatore i esiste solo all'interno del ciclo: dopo la parentesi graffa di chiusura non c'è più.

Contare in avanti, all'indietro e a passi

Le tre parti ti danno il pieno controllo del contatore:

public class Main {
    public static void main(String[] args) {
        for (int i = 10; i > 0; i--) {       // conta all'indietro
            System.out.print(i + " ");
        }
        System.out.println();

        for (int i = 0; i <= 20; i += 5) {   // avanza di 5 in 5
            System.out.print(i + " ");
        }
    }
}

i-- decrementa, i += 5 salta a passi di cinque: sono entrambi operatori aritmetici che fanno i conti sul contatore. La condizione decide quando fermarsi in base alla direzione: usa > quando conti all'indietro, < o <= quando conti in avanti.

Scorrere un array

Un ciclo con contatore si abbina in modo naturale a un array, usando .length come limite e i come indice:

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        for (int i = 0; i < colors.length; i++) {
            System.out.println(i + ": " + colors[i]);
        }
    }
}

Nota che colors.length è un campo senza parentesi: gli array sono speciali in questo. Una List usa invece list.size(). La condizione i < colors.length è corretta: gli indici vanno da 0 a length - 1, quindi usare < (e non <=) evita un errore di indice fuori intervallo.

Il ciclo for-each migliorato

Quando ti serve solo ogni elemento e mai l'indice, il for migliorato è più pulito e più difficile da sbagliare: non c'è un contatore con cui commettere errori di uno:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> colors = List.of("red", "green", "blue");

        for (String color : colors) {
            System.out.println(color.toUpperCase());
        }
    }
}

Leggi for (String color : colors) come "per ogni color in colors". Funziona sugli array e su qualsiasi cosa iterabile. Il compromesso: non hai l'indice e non puoi aggiungere o rimuovere elementi dalla collezione durante il ciclo (farlo lancia un'eccezione a runtime, ConcurrentModificationException). Usa il ciclo con contatore quando ti serve una di queste due cose.

Cicli annidati

Un ciclo dentro un ciclo è utile per griglie, tabelle e abbinamenti. Il ciclo interno viene eseguito per intero a ogni passaggio di quello esterno:

public class Main {
    public static void main(String[] args) {
        for (int row = 1; row <= 3; row++) {
            for (int col = 1; col <= 3; col++) {
                System.out.print(row * col + "\t");
            }
            System.out.println();
        }
    }
}

Questo stampa una tabellina 3x3. Quando l'annidamento si fa profondo, dai ai contatori nomi significativi (row, col) invece di i, j: ti evita di confondere l'uno con l'altro.

break e continue

break esce subito dal ciclo. continue salta il resto del passaggio corrente e passa direttamente all'aggiornamento:

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) continue;   // salta i numeri pari
            if (i > 7) break;           // fermati dopo il 7
            System.out.println(i);
        }
    }
}

Questo stampa 1 3 5 7. continue salta i pari; break chiude il ciclo quando i supererebbe 7. Nei cicli annidati, entrambi agiscono solo sul ciclo più interno, a meno che tu non usi un break con etichetta.

Attenzione ai cicli infiniti

Se la condizione non diventa mai falsa, il ciclo gira per sempre. La causa tipica è dimenticare l'aggiornamento o spostare il contatore nella direzione sbagliata:

for (int i = 0; i < 5; i--) {   // i diminuisce soltanto -> non arriva mai a 5
    System.out.println(i);
}

Un ciclo infinito voluto omette tutte e tre le parti, for (;;) { ... }, e si affida a un break interno per fermarsi. Usalo con parsimonia; di solito un while (true) si legge meglio.

Prossimo passo: i cicli while

Il ciclo for dà il meglio quando conosci il contatore in anticipo. Quando vuoi ripetere finché una condizione non cambia, e non hai un contatore chiaro, il ciclo while è più adatto. È l'argomento della prossima pagina.