Array multidimensionali: dichiarazione
Un array multidimensionale è un array i cui elementi sono a loro volta array.

Il caso più semplice è quello in cui gli elementi sono array monodimensionali. In questo caso si ottengono delle strutture chiamate matrici, di dimensione 2. Le matrici sono l'unico caso di array multidimensionale che analizziamo.

La dichiarazione di un array multidimensionale è del tutto analoga a quella di un array monodimensionale, con la differenza che bisogna riportare tante coppie di parentesi quadre quante sono le dimensioni dell'array.

Un esempio di dichiarazione di array bidimensionale 
int[][] matrix = new int[4][5];


//equivalentemente:

int[][] matrix;
matrix = new int[4][5];

dichiara una matrice di interi di dimensioni 4x5 (quattro righe e cinque colonne).

Matrice 4x5

  Array multidimensionali: accesso
Si può accedere ad un singolo elemento di un array bidimensionale usando doppi indici (per righe e colonne). Ad esempio matrix[3][1] seleziona il secondo elemento della quarta riga. 

matrix[3][1]

Usando un solo indice si seleziona una riga della matrice. Ad esempio, matrix[3] seleziona la quarta riga di matrix  ed è perciò un array di interi di lunghezza matrix[3].length (cioè 5).
 

Organizzazione in memoria
Un array multidimensionale viene memorizzato come un array di array. 

Quando si crea un array multidimensionale con new, si può lasciare non specificata una dimensione (insieme alle dimensioni che seguono): in questo caso gli elementi corrispondenti alle dimensioni non specificate sono riferimenti vuoti (null). 

int[][] a = new int[3][]; 

int[][] b = new int[][3]; // NON CONSENTITO!

String[][][] bigArray = new String[2][][];

Il primo esempio dichiara una matrice a di 3 elementi, ciascuno dei quali è un riferimento ad un array monodimensionale di lunghezza non specificata. Sarà quindi necessario inizializzare ogni elemento usando l'operatore new.
  

    // Per esempio possiamo
    // usare la stessa dimensione
    // per tutti gli elementi:
    a[0] = new int[4];
    a[1] = new int[4];
    a[2] = new int[4];

    // Oppure possiamo usare
    // dimensioni diverse
    // per ogni elemento:
    a[0] = new int[3];
    a[1] = new int[5];
    a[2] = new int[7];

Array multidimensionali: inizializzazione
Analogamente agli array monodimensionali, anche gli array multidimensionali possono essere inizializzati in fase di dichiarazione. 

public class TavolaPitagorica { 

    /* Stampa il numero delle righe, la lunghezza 
       della prima riga e il quarto elemento della terza 
       riga di una tavola pitagorica di dimensioni 3x4. 
    */ 
    public static void main (String args []){ 
        int tavola [][] = { 
            { 1*1, 1*2, 1*3, 1*4 }, 
            { 2*1, 2*2, 2*3, 2*4 }, 
            { 3*1, 3*2, 3*3, 3*4 } 
        }; 
        System.out.println (tavola.length); 
        System.out.println (tavola[0].length); 
        System.out.println (tavola[2][3]); 
    } 
} 

Spesso è conveniente usare dei cicli annidati per inizializzare / accedere gli elementi di un array multidimensionale. Come esempio vediamo la versione "parametrica" del programma precedente: 

public class TavolaPitagoricaFor { 

    /* Stampa il numero delle righe, la lunghezza 
       della prima riga e il quarto elemento della terza 
       riga di una tavola pitagorica di dimensioni 3x4. 
    */ 
    public static void main (String args []){ 

        final int ROW = 3;
        final int COL = 4;

        int[][] tavola = new int[ROW][COL]; 

        for (int i=0 ; i<tavola.length ; i++)
            for (int j=0 ; j<tavola[i].length ; j++)
                tavola[i][j] = (i+1)*(j+1);

        System.out.println (tavola.length); 
        System.out.println (tavola[0].length); 
        System.out.println (tavola[2][3]); 
    } 
} 

 
 

Operare su matrici: un esempio
L'uso di cicli annidati consente di scrivere in maniera naturale gli algoritmi che operano su matrici (o più in generale, che operano su array multidimensionali). Ad esempio, vediamo come scrivere un programma che calcola la somma di tutti gli elementi di una matrice e stampa il risultato: 

public class SommaMatrice {

    // Somma gli elementi della matrice di interi A. 
    // Si noti che funziona qualunque sia la dimensione della 
    // matrice, e anche se le righe hanno dimensione diversa 
    public static void main (String [] args) {

        int [][] a = {
            {1, 2, 3, 4, 5},
            {4, 8, 3, 2, 7},
            {10, 7, 3, 6, 8},
            {9, 2, 8, 3, 1}
        };
        int somma=0;
        for (int i=0; i< a.length; i++)
            for (int j=0; j<a[i].length; j++)
                somma = somma + a[i][j]; 

        System.out.println (somma);
    }
}

Per convenienza, riportiamo sotto la matrice sulla quale opera l'algoritmo dell'esempio.

Matrice