Cicli sugli array Java

Leggere array[0], array[1], array[2] a mano smette di scalare intorno alla lunghezza 3. Una volta che hai creato un array, Java ti offre diversi modi per visitare ogni elemento — scegli quello che si adatta a ciò che devi effettivamente fare. Questa pagina tratta il for basato su indice, il for avanzato (for-each), gli stream sugli array e come scegliere tra di essi.

Il ciclo for classico

Il for basato su indice è la forma più flessibile ed è l'unica che ti dà la posizione corrente:

int[] scores = {90, 85, 73, 100, 62};
for (int i = 0; i < scores.length; i++) {
  System.out.println(i + ": " + scores[i]);
}

Usalo quando hai bisogno di:

• l'indice (per stamparlo, per confrontare elementi adiacenti, per saltare avanti)
• percorrere l'array in senso inverso — for (int i = scores.length - 1; i >= 0; i--)
• avanzare di più di uno — i += 2
• modificare l'array — assegnando a scores[i]

Il limite è sempre i < array.length, mai un numero scritto direttamente nel codice. Se l'array cambia dimensione in seguito (o viene passato da altrove), il ciclo funziona comunque.

length è un campo, quindi non ci sono parentesi: scrivi scores.length, non scores.length(). (Le stringhe sono diverse — String ha un metodo length().) Quando l'array è vuoto, length è 0 e il corpo del ciclo non viene mai eseguito, che è esattamente quello che vuoi — non è necessario nessun controllo speciale. Consulta il capitolo sul ciclo for per la meccanica generale.

Il for avanzato — "for-each"

Quando hai bisogno solo del valore di ogni elemento nell'ordine, il for avanzato è più breve e più chiaro:

int[] scores = {90, 85, 73, 100, 62};
int sum = 0;
for (int score : scores) {
  sum += score;
}
System.out.println("sum = " + sum);

Leggi i due punti come "in": "per ogni int score in scores." La variabile del ciclo è una copia fresca di ogni elemento. Non puoi ottenere l'indice in questo modo, e non puoi modificare l'array tramite score — assegnare a score ridefinisce solo la variabile locale.

Usa il for avanzato per "fare qualcosa con ogni valore." Usa il for classico ogni volta che l'indice è importante.

Lettura e scrittura all'interno di un ciclo

All'interno di un for classico, array[i] = newValue modifica l'array in-place:

int[] scores = {90, 85, 73, 100, 62};
for (int i = 0; i < scores.length; i++) {
  scores[i] = scores[i] + 5;     // give everyone a 5-point bonus
}

Il for avanzato non può farlo per i tipi primitivi — score = score + 5 modifica solo la copia locale:

for (int score : scores) {
  score = score + 5;             // no effect on scores
}

Per gli array di oggetti, la variabile del ciclo fa ancora riferimento allo stesso oggetto dello slot dell'array, quindi chiamare metodi mutanti su di essa cambia effettivamente ciò che l'array vede. Ma riassegnare la variabile non lo fa.

Stream sugli array

Per gli array numerici, il metodo Arrays.stream(...) ti offre un'API in stile pipeline:

import java.util.Arrays;

int[] scores = {90, 85, 73, 100, 62};
int total = Arrays.stream(scores).sum();
double avg  = Arrays.stream(scores).average().orElse(0);
int max     = Arrays.stream(scores).max().orElse(0);

Per gli array di oggetti, Arrays.stream(...) restituisce uno Stream<T> con i soliti metodi filter/map/reduce:

String[] names = {"Ada", "Linus", "Grace"};
long shortOnes = Arrays.stream(names).filter(n -> n.length() <= 3).count();

Gli stream sono espressivi ma non sono gratuiti — per i cicli interni più stretti, un semplice for è più veloce e più facile da debuggare. Usa gli stream quando l'intenzione (somma, filtra-poi-conta, raggruppa, trasforma) è ciò che vuoi rendere evidente. Consulta Java streams per l'API completa della pipeline.

forEach dal lato dell'array

Non esiste array.forEach(...). Gli equivalenti più simili sono Arrays.stream(arr).forEach(...) (numerico o oggetto) oppure, per gli array di oggetti, il collegamento Arrays.asList(arr).forEach(...). La maggior parte delle volte il for semplice o il for avanzato va bene — non ricorrere a forEach solo per usare una sintassi diversa.

Scegliere un ciclo

Un esempio pratico

Cosa c'è dopo

Ora sai creare array e scorrerli in ogni direzione. I dati nel mondo reale sono spesso bidimensionali — una griglia, una tabella, una scacchiera — e Java lo supporta con gli array multidimensionali, che sono in realtà array di array.

Pratica