Array in Java

Un array in Java è un contenitore a dimensione fissa che contiene una sequenza di valori dello stesso tipo. Una volta creato, la sua lunghezza non cambia mai e ogni slot può contenere esattamente un valore — un int, una String, un riferimento a qualsiasi oggetto, qualunque cosa corrisponda al tipo dichiarato.

Gli array sono la base su cui si costruiscono le altre collezioni di Java (ArrayList, HashMap e simili). Non sono ergonomici come queste classi di livello superiore, ma sono veloci, prevedibili e li troverai ovunque — argomenti di metodi, valori di ritorno, codice sensibile alle prestazioni.

Dichiarare un array

Il tipo di un array è il tipo degli elementi seguito da []:

int[] scores;       // an array of ints
String[] names;     // an array of String references
double[] prices;    // an array of doubles

Le parentesi quadre possono anche essere messe dopo il nome della variabile — int scores[]; — ma la forma int[] scores è molto più comune ed è quella che dovresti usare.

Dichiarare una variabile non crea ancora un array; fornisce solo a Java uno slot che può contenere un riferimento a uno. Lo slot inizia come null.

Creare un array con new

Per allocare effettivamente l'array, usa new con una lunghezza:

int[] scores = new int[5];

Questo riserva spazio per 5 interi. Java inizializza ogni slot al valore predefinito del tipo:

• tipi numerici → 0 (o 0.0)
• boolean → false
• char → '�' (il carattere null, code point 0 — non uno spazio)
• tipi riferimento → null

Quindi scores contiene immediatamente {0, 0, 0, 0, 0}. Non esiste uno stato "non inizializzato" — una volta creato l'array, ogni posizione ha un valore definito.

Letterali di array

Quando conosci il contenuto in anticipo, usa un letterale:

int[] scores = {90, 85, 73, 100, 62};
String[] colors = {"red", "green", "blue"};

La lunghezza viene dedotta dal numero di elementi. Questa forma è valida solo sulla stessa riga della dichiarazione — non puoi scrivere scores = {90, 85}; in seguito. Per farlo, usa la forma esplicita:

scores = new int[]{90, 85, 73, 100, 62};

Accedere agli elementi

Puoi leggere e scrivere elementi tramite indice a base zero, usando le parentesi quadre:

int[] scores = {90, 85, 73, 100, 62};
System.out.println(scores[0]);   // 90
System.out.println(scores[4]);   // 62
scores[2] = 80;                  // replace 73 with 80

Gli indici validi vanno da 0 fino a length - 1. Un indice fuori intervallo lancia ArrayIndexOutOfBoundsException a runtime — Java non restituisce silenziosamente un valore predefinito né va in ciclo.

La proprietà length

Ogni array ha un campo pubblico di sola lettura length che riporta la sua dimensione:

int[] scores = {90, 85, 73, 100, 62};
System.out.println(scores.length);   // 5

Nota che è un campo, non un metodo — senza parentesi. Questa è una delle piccole stranezze di Java: le stringhe usano .length(), gli array usano .length. Si comportano in modo diverso anche dalle collezioni (list.size()). Le forme sono facili da confondere; il compilatore te lo dirà.

length è fisso al momento della creazione. Per "espandere" un array devi allocarne uno nuovo e copiare — vedi il capitolo Copiare gli array.

Gli array contengono riferimenti, non copie

Quando il tipo degli elementi è un oggetto, l'array memorizza riferimenti, non gli oggetti stessi:

String[] colors = {"red", "green", "blue"};
String first = colors[0];
// first and colors[0] both reference the same "red" string

Per i tipi primitivi questa distinzione non conta — i valori int vengono copiati dentro e fuori. Per gli oggetti, modificare un elemento dall'esterno dell'array modifica anche ciò che l'array vede, perché condividono il riferimento.

Valori predefiniti e array null

Una variabile array dichiarata ma non assegnata è null, e leggere .length o qualsiasi indice su di essa lancia NullPointerException:

int[] data;            // not initialized
// System.out.println(data.length);  // would throw NullPointerException
data = new int[3];
System.out.println(data.length);     // 3

Un array vuoto — di lunghezza zero — è un array perfettamente valido, ed è di solito quello che si vuole come valore di ritorno "vuoto", non null:

int[] none = new int[0];
System.out.println(none.length);     // 0

Un esempio pratico

Stampare un array

Una sorpresa comune: passare un array direttamente a System.out.println non mostra il suo contenuto. Stampa invece il tipo e l'hash di identità dell'array:

int[] scores = {90, 85, 73};
System.out.println(scores);   // e.g. [I@39ed3c8d  — not the values!

[I significa "array di int", e la parte esadecimale è un hash di identità, non i dati. Per vedere gli elementi, usa Arrays.toString dal pacchetto java.util:

import java.util.Arrays;

int[] scores = {90, 85, 73};
System.out.println(Arrays.toString(scores));   // [90, 85, 73]

Per array annidati (multidimensionali), usa invece Arrays.deepToString.

Cosa c'è dopo

Puoi costruire un array e accedere ai suoi elementi tramite indice. Il passo successivo è l'iterazione — visitare ogni elemento a turno con i cicli sugli array, così non devi scrivere scores[0], scores[1], scores[2] uno per uno.

Esercitati