Array Multidimensionali in Java
Array multidimensionali
Dal punto di vista concettuale, un array multidimensionale è un array in cui ogni elemento è un altro array. In altre parole, un array multidimensionale è un array di array. Gli array multidimensionali sono utili per rappresentare strutture dati più complesse, come matrici o tabelle.
In Java, gli array multidimensionali sono implementati come array di array.
Per dichiarare una variabile di array multidimensionale, bisogna specificare ogni indice aggiuntivo usando un'altra coppia di parentesi quadre. Ad esempio, il seguente comando dichiara una variabile di array bidimensionale chiamata dueD:
int[][] dueD = new int[4][5];
Questo istruisce il sistema ad allocare un array 4 per 5 e lo assegna a dueD. Internamente, questa matrice è implementata come un array di array di int. Concettualmente, questo array apparirà come quello mostrato nella figura che segue:
Il primo indice corrisponde alla riga mentre il secondo alla colonna.
Il programma seguente alloca un array bidimensionale di interi e lo riempie con i numeri da 0 a 19. Successivamente, visualizza il contenuto dell'array. Si noti che gli array multidimensionali sono indicizzati in modo simile agli array monodimensionali, ma con due indici: uno per la riga e uno per la colonna.
// Dimostrare un array bidimensionale.
class ArrayDueD {
public static void main(String[] argomenti) {
int[][] dueD = new int[4][5];
int i, j, k = 0;
for (i = 0; i < 4; i++)
for (j = 0; j < 5; j++) {
dueD[i][j] = k;
k++;
}
for (i = 0; i < 4; i++) {
for (j = 0; j < 5; j++)
System.out.print(dueD[i][j] + " ");
System.out.println();
}
}
}
Questo programma produce il seguente output:
0 1 2 3 4
5 6 7 8 9
10 11 12 13 14
15 16 17 18 19
Quando si alloca memoria per un array multidimensionale, è necessario specificare la memoria solo per la prima dimensione (quella più a sinistra). È possibile allocare separatamente le dimensioni restanti.
Per esempio, il codice seguente alloca la memoria per la prima dimensione di dueD al momento della dichiarazione. Alloca la seconda dimensione separatamente.
int[][] dueD = new int[4][];
dueD[0] = new int[5];
dueD[1] = new int[5];
dueD[2] = new int[5];
dueD[3] = new int[5];
Array multidimensionali irregolari
Esistono anche array multidimensionali irregolari, in cui le dimensioni non sono uniformi. In altre parole, ogni riga dell'array può avere una lunghezza diversa. Questi array sono utili quando si desidera rappresentare dati che non hanno una struttura regolare. Spesso vengono anche chiamati array irregolari o array jagged.
Per esempio, allocando le dimensioni singolarmente, non è necessario allocare lo stesso numero di elementi per ciascuna dimensione. Come affermato in precedenza, poiché gli array multidimensionali sono effettivamente array di array, la lunghezza di ciascun array è sotto controllo. Ad esempio, il programma seguente crea un array bidimensionale in cui le dimensioni della seconda dimensione sono diseguali:
// Allocare manualmente secondi dimensioni di dimensione differente.
class DueDAncora {
public static void main(String[] argomenti) {
int[][] dueD = new int[4][];
dueD[0] = new int[1];
dueD[1] = new int[2];
dueD[2] = new int[3];
dueD[3] = new int[4];
int i, j, k = 0;
for (i = 0; i < 4; i++)
for (j = 0; j < i + 1; j++) {
dueD[i][j] = k;
k++;
}
for (i = 0; i < 4; i++) {
for (j = 0; j < i + 1; j++)
System.out.print(dueD[i][j] + " ");
System.out.println();
}
}
}
Questo programma produce il seguente output:
0
1 2
3 4 5
6 7 8 9
L'array creato da questo programma appare così:
L'utilizzo di array multidimensionali non uniformi (o irregolari) potrebbe non essere adatto a molte applicazioni, poiché contrasta con ciò che ci si aspetta quando si incontra un array multidimensionale. Tuttavia, gli array irregolari possono risultare efficaci in alcune situazioni. Per esempio, se occorre un array bidimensionale molto grande ma scarsamente popolato (cioè uno in cui non verranno usati tutti gli elementi), un array irregolare può rappresentare la soluzione ideale.
È possibile inizializzare array multidimensionali. A tal fine, racchiudere semplicemente l'inizializzatore di ogni dimensione nella propria coppia di parentesi graffe. Il programma seguente crea una matrice in cui ciascun elemento contiene il prodotto degli indici di riga e di colonna. Si noti che, all'interno degli inizializzatori di array, è possibile usare sia espressioni sia valori letterali.
// Inizializzare un array bidimensionale.
class Matrice {
public static void main(String[] argomenti) {
double[][] m = {
{ 0*0, 1*0, 2*0, 3*0 },
{ 0*1, 1*1, 2*1, 3*1 },
{ 0*2, 1*2, 2*2, 3*2 },
{ 0*3, 1*3, 2*3, 3*3 }
};
int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++)
System.out.print(m[i][j] + " ");
System.out.println();
}
}
}
Quando si esegue questo programma, viene prodotto il seguente output:
0.0 0.0 0.0 0.0
0.0 1.0 2.0 3.0
0.0 2.0 4.0 6.0
0.0 3.0 6.0 9.0
Come si può notare, ogni riga dell'array è inizializzata secondo le liste di inizializzazione.
Si consideri ora un ultimo esempio che utilizza un array multidimensionale. Il programma seguente crea un array tridimensionale 3 × 4 × 5. Successivamente, carica ogni elemento con il prodotto dei propri indici e infine visualizza tali prodotti.
// Dimostrare un array tridimensionale.
class Matrice3D {
public static void main(String[] argomenti) {
int[][][] treD = new int[3][4][5];
int i, j, k;
for (i = 0; i < 3; i++)
for (j = 0; j < 4; j++)
for (k = 0; k < 5; k++)
treD[i][j][k] = i * j * k;
for (i = 0; i < 3; i++) {
for (j = 0; j < 4; j++) {
for (k = 0; k < 5; k++)
System.out.print(treD[i][j][k] + " ");
System.out.println();
}
System.out.println();
}
}
}
Questo programma genera il seguente output:
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 1 2 3 4
0 2 4 6 8
0 3 6 9 12
0 0 0 0 0
0 2 4 6 8
0 4 8 12 16
0 6 12 18 24
Iterazione sugli array multidimensionali
La versione migliorata di for, ossia il for-each, funziona anche con gli array multidimensionali.
Occorre tuttavia ricordare che, in Java, gli array multidimensionali sono composti da array di array. (Per esempio, un array bidimensionale è un array di array monodimensionali.) Ciò è importante quando si itera su un array multidimensionale, perché ogni iterazione ottiene l'array successivo, non un elemento individuale.
Inoltre, la variabile di iterazione nel ciclo for deve essere compatibile con il tipo di array ottenuto. Ad esempio, nel caso di un array bidimensionale, la variabile di iterazione deve essere un riferimento a un array monodimensionale. In generale, quando si usa il for-each per iterare su un array di N dimensioni, gli oggetti ottenuti saranno array di N – 1 dimensioni.
Per comprenderne le implicazioni, si consideri il seguente programma. Esso utilizza cicli for innestati per ottenere gli elementi di un array bidimensionale in ordine di riga, dal primo all'ultimo:
// Usare lo stile for-each su un array bidimensionale.
class PerOgni3 {
public static void main(String[] argomenti) {
int somma = 0;
int[][] numeri = new int[3][5];
// assegnare alcuni valori a numeri
for (int i = 0; i < 3; i++)
for (int j = 0; j < 5; j++)
numeri[i][j] = (i + 1) * (j + 1);
// usare for-each per visualizzare e sommare i valori
for (int[] x : numeri) {
for (int y : x) {
System.out.println("Il valore è: " + y);
somma += y;
}
}
System.out.println("Somma: " + somma);
}
}
Questo programma produce il seguente output:
Il valore è: 1
Il valore è: 2
Il valore è: 3
Il valore è: 4
Il valore è: 5
Il valore è: 2
Il valore è: 4
Il valore è: 6
Il valore è: 8
Il valore è: 10
Il valore è: 3
Il valore è: 6
Il valore è: 9
Il valore è: 12
Il valore è: 15
Somma: 90
Nel programma occorre prestare particolare attenzione a questa riga:
for (int[] x : numeri) {
Si noti come x viene dichiarata: è un riferimento a un array monodimensionale di interi. Ciò è necessario perché ogni iterazione del for ottiene l'array successivo in numeri, a partire dall'array specificato da numeri[0]. Il ciclo for interno percorre quindi ciascuno di questi array, visualizzando i valori di ogni elemento.