1. Introduzione
Immaginate un array normale come una lunga scatola da pizza, in cui tutti i pezzi sono in fila — buono, ma monotono.
Ora pensiamo a un orario di lavoro o a una scacchiera. Lì tutto è organizzato in righe e colonne — cioè in una tabella. Questo è il caso classico per un array bidimensionale.
Nella vita reale gli array bidimensionali si incontrano ovunque:
- Tabelle con gli stipendi dei dipendenti (righe — dipendenti, colonne — mesi).
- Un'immagine sullo schermo (ogni «cella» — il colore di un pixel, con due coordinate: X e Y).
- Calcoli su matrici e elaborazione dei dati.
- Una scacchiera o il campo del tris.
A volte un array bidimensionale viene chiamato matrice (termine che viene dalla matematica).
Ci sono moltissimi ambiti in cui, come programmatori, potreste aver bisogno di un array bidimensionale. L'implementazione di quasi qualsiasi gioco da tavolo — è un array bidimensionale bell'e pronto: «Scacchi», «Dama», «Tris», «Battaglia navale»:
Il campo di gioco degli «Scacchi» o di «Battaglia navale» si presta perfettamente agli array bidimensionali, dove come coordinate delle celle si usano solo numeri. Non «pedone e2 ⟶ e4», ma «pedone (4,1) ⟶ (4,3)». Per voi, come programmatori, sarà persino più semplice.
2. Sintassi di dichiarazione degli array bidimensionali
Fa paura solo fino alla prima dichiarazione! Vediamolo passo dopo passo.
Regola generale
tipo[][] nomeArray;Qui le due parentesi [] vuote — non sono un errore del compilatore dopo una notte di caffè, ma l'indicazione: l'array è bidimensionale.
Esempi
int[][] matrix;
double[][] gradesTable;
string[][] chessBoard;
Creazione dell'array
Stabiliamo le dimensioni: numero di righe e colonne.
matrix = new int[3][4]; // 3 righe, 4 colonne
È una tabella 3x4: immaginate un foglio Excel con 3 righe e 4 colonne.
Si può dichiarare la variabile e creare subito un array bidimensionale:
int[][] matrix = new int[3][4];
Si può anche inizializzare subito con dei valori (più o meno come con un array monodimensionale):
int[][] example = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// Tabella 3 righe, 3 colonne
Schema visivo
┌─────┬─────┬─────┬─────┐
│ 0 │ 1 │ 2 │ 3 │ ← colonne (Columns)
├─────┼─────┼─────┼─────┤
│ 0,0 │ 0,1 │ 0,2 │ 0,3 │ ← riga 0 (Row 0)
├─────┼─────┼─────┼─────┤
│ 1,0 │ 1,1 │ 1,2 │ 1,3 │ ← riga 1 (Row 1)
├─────┼─────┼─────┼─────┤
│ 2,0 │ 2,1 │ 2,2 │ 2,3 │ ← riga 2 (Row 2)
└─────┴─────┴─────┴─────┘
Ogni elemento è definito da una coppia di indici [riga, colonna].
3. Indicizzazione e accesso agli elementi
In un array bidimensionale, per accedere a un elemento si indicano due indici:
- Il primo — il numero della riga.
- Il secondo — il numero della colonna.
// Nella seconda riga (indice 1), terza colonna (indice 2)
matrix[1][2] = 99;
Se siete abituati agli scacchi, ricordate: l'indicizzazione parte da zero. Quindi il primo elemento — è [0][0].
Scrittura e lettura
int[][] data = new int[5][2];
data[1][1] = 5; // scrittura
int value = data[1][1]; // lettura
Ecco come apparirà in memoria:
4. Riempimento di un array bidimensionale
Scriviamo del codice che riempia la matrice con numeri consecutivi da 1 a 12, così da capire come funziona.
int[][] matrix = new int[3][4];
int value = 1;
for (int row = 0; row < 3; row++)
{
for (int col = 0; col < 4; col++)
{
matrix[row][col] = value;
value++;
}
}
Illustrazione:
Dopo l'esecuzione:
┌────┬────┬────┬────┐
│ 1 │ 2 │ 3 │ 4 │
├────┼────┼────┼────┤
│ 5 │ 6 │ 7 │ 8 │
├────┼────┼────┼────┤
│ 9 │ 10 │ 11 │ 12 │
└────┴────┴────┴────┘
5. Com'è fatto un array bidimensionale
Ora scoprirete come sono realmente strutturati gli array bidimensionali. Pronti?
Gli array bidimensionali — sono in realtà array di array!
In altre parole, se nel caso di un array normale «la variabile-array contiene un riferimento a un contenitore che conserva gli elementi dell'array», nel caso degli array bidimensionali la situazione è un po' più esplosiva: la variabile-array-bidimensionale contiene un riferimento a un contenitore che conserva riferimenti ad array monodimensionali. Meglio vederlo una volta che provarci a spiegarlo cento volte:
A sinistra abbiamo la «variabile-array-bidimensionale», che contiene un riferimento all'«oggetto-array-bidimensionale». Al centro abbiamo l'«oggetto array bidimensionale», nelle cui celle sono memorizzati riferimenti ad array monodimensionali — le righe dell'array bidimensionale. E a destra vedete quattro array monodimensionali — le righe del nostro array bidimensionale.
Ecco come sono realmente organizzati gli array bidimensionali. Questo approccio offre al programmatore Java diversi vantaggi:
Per prima cosa, poiché il «contenitore di contenitori» conserva riferimenti agli «array-riga», possiamo scambiare le righe in modo molto rapido e semplice. Per accedere al «contenitore di contenitori» basta indicare un solo indice invece di due. Esempio:
int[][] data = new int[2][5];
int[] row1 = data[0];
int[] row2 = data[1];
Con un codice come questo si possono scambiare le righe:
// Matrice importante con i dati
int[][] matrix = {
{1, 2, 3, 4, 5},
{5, 4, 3, 2, 1}
};
int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;
Se accedete a una cella di un array bidimensionale ma, dopo il nome dell'array, specificate un solo indice, in realtà accederete al contenitore-di-contenitori, nelle cui celle sono memorizzati riferimenti a normali array monodimensionali.
6. Stampa di un array bidimensionale a schermo
Per stampare una tabella bidimensionale si usa di solito un doppio ciclo — è come disegnare un labirinto in console. Esempio:
for (int row = 0; row < matrix.length; row++)
{
for (int col = 0; col < matrix[row].length; col++)
{
System.out.print(matrix[row][col] + "\t");
}
System.out.println(); // passaggio a una nuova riga
}
Esempio di output:
1 2 3 4
5 6 7 8
9 10 11 12
A proposito, qui avete imparato a «disegnare» belle tabelle con poche righe di codice!
GO TO FULL VERSION