1. Un array — è un contenitore di elementi
Probabilmente avete sentito dire che i computer possono elaborare enormi quantità di informazioni. L’istruzione condizionale (if-else) e i cicli (for, while) ovviamente aiutano in questo. Ma non si va lontano solo con quelli, perché i dati da elaborare devono pur essere memorizzati da qualche parte.
Per questo in Java, come praticamente in tutti i linguaggi di programmazione, esiste un’ottima cosa chiamata array (Array). Vengono anche chiamati tabelle.
Un array è un oggetto speciale nel quale si può memorizzare non un solo valore, ma più valori.
Se in precedenza abbiamo paragonato una variabile a una scatola (dove si può conservare qualche valore), allora un array è piuttosto una scatola divisa internamente in scomparti. Ogni scomparto nella «scatola-array» ha il suo numero. La numerazione, naturalmente, parte da zero...
Oppure possiamo fare un’altra analogia. Confrontiamo una casa unifamiliare e un condominio. Una casa unifamiliare è occupata da una sola famiglia, mentre un condominio è diviso in appartamenti. Per scrivere una lettera alla famiglia che vive in una casa unifamiliare, bisogna indicarne l’indirizzo univoco. Per scrivere a una famiglia che vive in un appartamento, bisogna indicare l’indirizzo univoco del palazzo e anche il numero dell’appartamento.
Ecco, una variabile-array è come un condominio. In essa si possono conservare non uno, ma più valori. In una tale variabile ci sono diversi appartamenti (celle), e a ciascuno si può accedere tramite il suo numero (indice).
Per farlo, dopo il nome della variabile tra parentesi quadre bisogna indicare l’indice della cella a cui accediamo. È piuttosto semplice:
array[indeks] = znachenie;Dove array è il nome della variabile-array, indice è il numero della cella nell’array e valore è il valore che vogliamo inserire nella cella indicata.
Ma cominciamo innanzitutto a capire come creare gli array.
2. Creare un array di elementi in Java
Supponiamo che il vostro programma debba memorizzare da qualche parte 100 numeri interi. Molto probabilmente, per questo è adatto un array. E come lo si crea?
Se volessimo memorizzare un solo numero intero, ci basterebbe il tipo int; ma se vogliamo memorizzare 100 numeri interi, probabilmente ci serve un array di tipo int. Ecco come apparirebbe il codice per crearlo:
int[] array = new int[100];Vediamo cosa c’è scritto qui.
Come avrete già intuito, a sinistra dell’uguale si trova la dichiarazione della variabile di nome array e di tipo int[]. Dopo il tipo int seguono le parentesi quadre, che suggeriscono che nelle «scatole» di questo tipo si potranno conservare non uno, ma più valori.
A destra dell’uguale c’è la «creazione dell’oggetto» (la parola new) con 100 elementi (celle) di tipo int. Anche questo non è troppo difficile.
Se volessimo, ad esempio, creare un array da 20 celle per memorizzare numeri in virgola mobile, il codice di creazione sarebbe più o meno così:
double[] vals = new double[20];Il numero di celle in un array si chiama dimensione dell’array o lunghezza dell’array. E per la capacità di conservare molti valori gli array vengono anche chiamati contenitori.
Fatto importante: la dimensione del contenitore array non può essere modificata dopo la creazione.
Si può crearne uno nuovo, ma la lunghezza del contenitore già creato non può essere cambiata.
3. Lavorare con le celle dell’array
Bene, abbiamo imparato a creare gli array: come usarli correttamente?
Praticamente allo stesso modo delle variabili normali, solo che dopo il nome della variabile-array è necessario indicare il numero della cella con cui stiamo lavorando.
La numerazione delle celle di un array inizia sempre da zero. Se abbiamo un array di 10 elementi, i numeri (indici) delle celle sono 0..9; se l’array ha 200 elementi, allora 0..199. E così via per analogia.
Esempi:
int[] a = new int[10]; // Creiamo un array di 10 elementi di tipo int.
a[2] = 4; // Nella cella con indice 2 scriviamo il valore 4.
a[7] = 9; // Nella cella con indice 7 scriviamo il valore 9.
a[9] = a[2] + a[5]; // Nella cella con indice 9 scriviamo la somma dei valori memorizzati nelle celle 2
// (c’è 4) e 5 (c’è 0).
Ecco cosa sarà memorizzato in memoria dopo l’esecuzione di questo codice:
La colonna a sinistra dell’array (in grigio) è l’elenco dei numeri (indici) delle celle. Nelle celle sono memorizzati i valori inseriti: 4, 9 e 4. Subito dopo la creazione, le celle di un array sono riempite di zeri.
Importante. Tutte le celle di un array hanno lo stesso tipo di dati. Se abbiamo creato un array di stringhe String, nelle sue celle si possono conservare solo stringhe. Il tipo di dati dell’array viene definito al momento della creazione. Né il tipo dei dati né la lunghezza dell’array possono essere cambiati in seguito.
4. Gli array in memoria
Le immagini nei precedenti esempi sono un po’ imprecise.
Quando si creano gli array (così come quando si creano le stringhe) in memoria vengono allocati due blocchi: uno per memorizzare l’array stesso (il contenitore) e un altro per la variabile che ne conserva l’indirizzo. La situazione più precisa è mostrata nell’immagine qui sotto:
In verde è rappresentato un array di 10 elementi di tipo int e una variabile di tipo int[] che memorizza l’indirizzo (riferimento) dell’array di tipo int in memoria.
Per confronto, in blu è indicata una variabile normale di tipo int, che memorizza il valore 199.
Ricorda qualcosa del modo in cui sono memorizzate le stringhe in memoria, non trovate?
Esatto, le stringhe. E, come quando si lavora con le stringhe, le «variabili di tipo array» si possono assegnare l’una all’altra:
int[] a = new int[10]; // Creiamo un array di 10 elementi di tipo int.
a[2] = 4; // Nella cella con indice 2 scriviamo il valore 4.
a[7] = 9; // Nella cella con indice 7 scriviamo il valore 9.
int[] b = a; // Nella variabile b salviamo l’indirizzo presente nella variabile a.
// Ora a e b puntano allo stesso oggetto-array in memoria.
a[9] = b[2] + a[7]; // Nella cella con indice 9 dell’oggetto-array scriviamo la somma dei valori
// che si trovano nelle celle 2 (c’è 4) e 7 (c’è 9).
L’oggetto-array, nel frattempo, rimarrà dov’è, e le variabili a e b conserveranno gli stessi indirizzi (riferimenti) allo stesso oggetto. Guardate l’immagine:
5. Lavorare con un array in modo più dettagliato
Un array si può creare a partire da qualsiasi tipo. Per farlo basta scrivere le parentesi quadre dopo il nome del tipo. La forma generale per creare un array è la seguente:
tip[] imya = new tip[kolichestvo];Dove tipo è il tipo degli elementi (celle) dell’array che memorizzeremo nell’array. Nome è il nome della variabile con cui accederemo all’array, e quantità è il numero di celle nell’array.
Nell’esempio sopra è mostrata la forma canonica: creazione della variabile-array e creazione dell’oggetto-array. In realtà sono due costrutti indipendenti. Si possono creare la variabile-array e l’oggetto-array separatamente:
tip[] imya;
imya = new tip[kolichestvo];E un altro punto importante
Come indice dell’array e come quantità di elementi dell’array possono essere utilizzate variabili e persino espressioni intere.
Esempi:
int n = 100;
int[] a = new int[n]; // Creazione di un array di n elementi
int n = 100;
int[] a = new int[n * 2 + 3]; // Creazione di un array di 203 elementi
int n = 100;
int[] a = new int[n];
a[n-1] = 2; // a[99] = 2;
a[n-2] = 3; // a[98] = 3;
a[n/5] = a[n-1] + a[n-2] // a[20] = a[99] + a[98];
Uscita dai limiti dell’array
Attenzione: se provate ad accedere a una cella dell’array con un indice che nell’array non esiste (nel nostro caso sono tutti i numeri interi tranne quelli compresi in 0..99), il programma terminerà in modo anomalo con l’errore ArrayIndexOutOfBoundsException — indice fuori dai limiti dell’array.
Lunghezza dell’array
Come abbiamo visto nell’esempio precedente, si può creare separatamente una variabile di tipo array e poi, da qualche parte nel codice, assegnarle un valore (un riferimento a un oggetto-array). Si può fare persino così:
int[] array; // Creiamo una variabile-array di tipo int[]
if (a < 10) // Se la variabile a è minore di 10,
array = new int[10]; // allora crea un array di 10 elementi.
else // Altrimenti
array = new int[20]; // crea un array di 20 elementi
E come lavorare poi con un array del genere? Come sapere quanti elementi contiene?
A tal fine l’array ha una proprietà (variabile) speciale — length. Si può ottenere la lunghezza dell’array tramite un’espressione come questa:
array.length;Dove array è il nome della variabile-array e length è il nome della proprietà dell’oggetto-array. Il valore della proprietà length non può essere modificato: si può assegnare la proprietà length ad altre variabili, ma non si può assegnare nulla a essa (il programma semplicemente non verrà compilato).
Ecco come possiamo continuare l’esempio precedente:
int[] array; // Creiamo una variabile-array di tipo int[]
if (a < 10) // Se la variabile a è minore di 10,
array = new int[10]; // allora crea un array di 10 elementi.
else // Altrimenti
array = new int[20]; // crea un array di 20 elementi
for (int i = 0; i < array.length; i++) // Ciclo su tutti gli elementi dell’array: da 0 fino a array.length − 1
{
System.out.println(array[i]);
}
7. Fatti sugli array in Java
Riepiloghiamo i fatti noti sugli array:
- Fatto 1. Un array è composto da molte celle.
- Fatto 2. L’accesso a una cella specifica avviene indicando il suo numero.
- Fatto 3. Tutte le celle sono dello stesso tipo.
- Fatto 4. Il valore iniziale per tutte le celle è 0 e null (se nella cella si memorizza un indirizzo), false (per il tipo boolean).
- Fatto 5. String[] list è solo la dichiarazione di una variabile: il contenitore (l’oggetto-array) non è ancora stato creato. Per poterci lavorare bisogna creare l’array (contenitore) e metterlo in questa variabile, e poi usarlo. Vedi l’esempio sotto.
- Fatto 6. Quando creiamo un oggetto-array (contenitore), bisogna indicarne la lunghezza — quante celle contiene. Questo si fa con un’istruzione del tipo: new TypeName[n];
- Fatto 7. La lunghezza dell’array si può ottenere tramite la proprietà .length.
- Fatto 8. Dopo la creazione di un array non si possono cambiare né il tipo dei suoi elementi né la loro quantità.
String s; // s vale null
String[] list; // list vale null
list = new String[10]; // La variabile list contiene il riferimento a un oggetto – un array di stringhe di 10 elementi.
int n = list.length; // n vale 10
list = new String[0]; // Ora list contiene un array di 0 elementi.
// L’array esiste, ma non può contenere elementi.
list = null;
System.out.println(list[1]); // Verrà generato un errore — il programma terminerà in modo anomalo.
// list contiene un riferimento vuoto — null
list = new String[10];
System.out.println(list[10]); // Verrà generato un errore — uscita dai limiti dell’array.
// Se list contiene 10 elementi/celle, allora gli indici consentiti sono: 0 1 2 3 4 5 6 7 8 9 — in totale 10.
GO TO FULL VERSION