Arrays Multidimensionais em Java

Java não possui um tipo "array 2D" separado. O que existe são arrays de arrays — um int[][] é um array cujos elementos são, por sua vez, int[]s. A sintaxe é curta o suficiente para parecer uma grade embutida, e na maioria das vezes você pode usá-la dessa forma. Se você é novo nos conceitos básicos, comece com arrays em Java; esta página constrói sobre aquela, uma dimensão por vez.

Esta página cobre a declaração e alocação de arrays 2D, leitura e escrita de células, obtenção do número de linhas e colunas, iteração, arrays irregulares (não retangulares) e o caso raro de dimensões superiores.

Declarando um array 2D

Adicione outro par de colchetes ao tipo:

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

Aloque com dois tamanhos — linhas primeiro, depois colunas:

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

Ou use um literal aninhado:

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

As chaves externas contêm três sub-arrays, cada um de comprimento 4.

Acessando elementos

Dois índices: linha primeiro, depois coluna.

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] sozinho é a primeira linha — ela própria um int[] de comprimento 3. Esse é o ponto principal a internalizar: indexar uma vez dá uma linha, indexar duas vezes dá uma célula.

length para linhas e colunas

grid.length é o número de linhas. grid[r].length é o número de colunas na linha r:

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

Não existe grid.cols de nível superior porque Java não presume que todas as linhas têm o mesmo comprimento — veja os arrays irregulares abaixo.

Iterando

O duplo for padrão:

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();
}

Ou com for aprimorado, tratando cada linha como um int[]:

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

Use a forma aprimorada quando não precisar das coordenadas, e a forma clássica quando precisar.

Arrays irregulares (jagged arrays)

Os arrays internos não precisam ter o mesmo comprimento. Um array de arrays em Java pode ser irregular — cada linha dimensionada de forma independente:

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};

Ou com um literal:

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

A iteração funciona exatamente da mesma forma — você pergunta a cada linha pelo seu próprio .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();
}

É por isso que int[][] é "array de arrays" e não uma matriz verdadeira: nada na linguagem obriga todas as linhas a terem a mesma largura.

Dimensões superiores

O padrão se estende. int[][][] é um array de arrays de arrays — útil para uma grade 3D, uma pilha de matrizes, uma imagem RGB (altura × largura × 3):

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

Na prática, qualquer coisa além de 2D é rara em Java idiomático — nesse ponto, uma classe com campos nomeados é quase sempre mais clara.

Um exemplo prático

O que vem a seguir

Você viu agora arrays em uma e mais dimensões. A seguir veremos as operações com arrays do dia a dia — obter o comprimento, preencher, buscar, copiar — e os utilitários da biblioteca padrão que tornam a maioria delas em chamadas de uma única linha.

Prática