Array Multidimensionali in Java

Java non ha un tipo "array 2D" separato. Quello che ha sono array di array — un int[][] è un array i cui elementi sono a loro volta int[]. La sintassi è abbastanza concisa da sembrare una griglia incorporata nel linguaggio, e nella maggior parte dei casi puoi usarla in questo modo. Se sei alle prime armi con le basi, inizia con gli array Java; questa pagina costruisce su quella, una dimensione alla volta.

Questa pagina tratta la dichiarazione e l'allocazione di array 2D, la lettura e la scrittura di celle, il conteggio di righe e colonne, l'iterazione, gli array irregolari (non rettangolari) e il raro caso di dimensioni superiori.

Dichiarare un array 2D

Aggiungi un'altra coppia di parentesi quadre al tipo:

int[][] grid;
String[][] board;

Alloca con due dimensioni — prima le righe, poi le colonne:

int[][] grid = new int[3][4];   // 3 rows, 4 columns, all zero

Oppure usa un letterale annidato:

int[][] grid = {
  {1, 2, 3, 4},
  {5, 6, 7, 8},
  {9, 10, 11, 12}
};

Le parentesi graffe esterne contengono tre sotto-array, ciascuno di lunghezza 4.

Accedere agli elementi

Due indici: prima la riga, poi la colonna.

int[][] grid = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
System.out.println(grid[0][0]);   // 1
System.out.println(grid[2][1]);   // 8
grid[1][1] = 50;                  // replace 5 with 50

grid[0] da solo è la prima riga — essa stessa un int[] di lunghezza 3. Questo è il concetto fondamentale da interiorizzare: indicizzare una volta dà una riga, indicizzare due volte dà una cella.

length per righe e colonne

grid.length è il numero di righe. grid[r].length è il numero di colonne nella riga r:

int rows = grid.length;
int cols = grid[0].length;   // assuming row 0 exists

Non esiste un grid.cols di alto livello perché Java non presuppone che ogni riga abbia la stessa lunghezza — vedi gli array irregolari di seguito.

Iterazione

Il doppio for standard:

for (int r = 0; r < grid.length; r++) {
  for (int c = 0; c < grid[r].length; c++) {
    System.out.print(grid[r][c] + " ");
  }
  System.out.println();
}

Oppure con il for potenziato, trattando ogni riga come un int[]:

for (int[] row : grid) {
  for (int cell : row) {
    System.out.print(cell + " ");
  }
  System.out.println();
}

Usa la forma potenziata quando non ti interessano le coordinate, la forma classica quando ti interessano.

Array irregolari (jagged)

Gli array interni non devono avere la stessa lunghezza. Un array di array in Java può essere irregolare (jagged) — ogni riga dimensionata in modo indipendente:

int[][] triangle = new int[4][];   // 4 rows, columns unspecified
triangle[0] = new int[]{1};
triangle[1] = new int[]{1, 2};
triangle[2] = new int[]{1, 2, 3};
triangle[3] = new int[]{1, 2, 3, 4};

Oppure con un letterale:

int[][] triangle = {
  {1},
  {1, 2},
  {1, 2, 3},
  {1, 2, 3, 4}
};

L'iterazione funziona esattamente nello stesso modo — chiedi a ogni riga la propria .length:

for (int r = 0; r < triangle.length; r++) {
  for (int c = 0; c < triangle[r].length; c++) {
    System.out.print(triangle[r][c] + " ");
  }
  System.out.println();
}

Ecco perché int[][] è "array di array" piuttosto che una vera matrice: nulla nel linguaggio impone che ogni riga abbia la stessa larghezza.

Dimensioni superiori

Lo schema si estende. int[][][] è un array di array di array — utile per una griglia 3D, una pila di matrici, un'immagine RGB (altezza × larghezza × 3):

int[][][] cube = new int[2][3][4];   // 2 × 3 × 4
cube[0][1][2] = 99;

In pratica, qualsiasi cosa oltre il 2D è rara nel Java idiomatico — a quel punto una classe con campi nominati è quasi sempre più chiara.

Un esempio pratico

Cosa viene dopo

Hai visto gli array in una e più dimensioni. Successivamente vedremo le operazioni sugli array di uso quotidiano — ottenere la lunghezza, riempire, cercare, copiare — e gli helper della libreria standard che rendono la maggior parte di esse operazioni in una riga sola.

Esercitati