Arrays bidimensionais

1. Introdução

Imagine um array comum como uma caixa longa de pizza, onde todos os pedaços ficam em fila — gostoso, mas monótono.

Agora pense em um cronograma de trabalhos ou em um tabuleiro de xadrez. Ali já está tudo organizado em linhas e colunas — ou seja, em uma tabela. Essa é a tarefa clássica para um array bidimensional.

Na vida real, arrays bidimensionais aparecem o tempo todo:

• Tabelas de salários dos funcionários (linhas — funcionários, colunas — meses).
• Uma imagem na tela (cada “célula” — a cor de um pixel; ela tem duas coordenadas: X e Y).
• Cálculo matricial e processamento de dados.
• Tabuleiro de xadrez ou campo para jogo da velha.

Às vezes, um array bidimensional é chamado de matriz (termo vindo da matemática).

Há muitos casos em que, como programador, você pode precisar de um array bidimensional. A implementação de praticamente qualquer jogo de tabuleiro é um array bidimensional pronto: “Xadrez”, “Damas”, “Jogo da velha”, “Batalha Naval”:

O tabuleiro de Xadrez ou de Batalha Naval se encaixa perfeitamente em arrays bidimensionais, onde, como coordenadas das casas, você usará apenas números. Não “peão e2 ⟶ e4”, e sim “peão (4,1) ⟶ (4,3)”. Para você, como programador, isso fica até mais fácil.

2. Sintaxe de declaração de arrays bidimensionais

Assusta só até a primeira declaração! Vamos entender passo a passo.

Regra geral

tip[][] imyaMassiva;

Aqui, dois pares de colchetes vazios [] não são um erro do compilador após uma noite com café, mas a indicação de que o array é bidimensional.

Exemplos

int[][] matrix;
double[][] gradesTable;
string[][] chessBoard;

Criação do array

Definimos os tamanhos: quantidade de linhas e colunas.

matrix = new int[3][4]; // 3 linhas, 4 colunas

É uma tabela 3x4: imagine uma planilha do Excel com 3 linhas e 4 colunas.

Você pode declarar a variável e criar o array bidimensional de uma vez:

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

Também é possível inicializar de imediato com valores (mais ou menos como com um unidimensional):

int[][] example = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
// Tabela: 3 linhas, 3 colunas

Esquema visual

┌─────┬─────┬─────┬─────┐
│  0  │  1  │  2  │  3  │  ← colunas (Columns)
├─────┼─────┼─────┼─────┤
│ 0,0 │ 0,1 │ 0,2 │ 0,3 │  ← linha 0 (Row 0)
├─────┼─────┼─────┼─────┤
│ 1,0 │ 1,1 │ 1,2 │ 1,3 │  ← linha 1 (Row 1)
├─────┼─────┼─────┼─────┤
│ 2,0 │ 2,1 │ 2,2 │ 2,3 │  ← linha 2 (Row 2)
└─────┴─────┴─────┴─────┘

Cada elemento é definido por um par de índices [linha, coluna].

3. Indexação e acesso aos elementos

Em um array bidimensional, para acessar um elemento você informa dois índices:

• O primeiro — o número da linha.
• O segundo — o número da coluna.

      // Na segunda linha (índice 1), terceira coluna (índice 2)
      matrix[1][2] = 99;

Para quem está acostumado ao xadrez, um lembrete: a indexação começa em zero. Ou seja, o primeiro elemento é [0][0].

Escrita e leitura

int[][] data = new int[5][2];
data[1][1] = 5;         // escrita
int value = data[1][1]; // leitura

Veja como isso ficará na memória:

4. Preenchendo um array bidimensional

Vamos escrever um código que preencha a matriz com números sequenciais de 1 até 12, para ficar claro como isso funciona.

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

Ilustração:

Após a execução:
┌────┬────┬────┬────┐
│ 1  │ 2  │ 3  │ 4  │
├────┼────┼────┼────┤
│ 5  │ 6  │ 7  │ 8  │
├────┼────┼────┼────┤
│ 9  │ 10 │ 11 │ 12 │
└────┴────┴────┴────┘

5. Estrutura dos arrays bidimensionais

Agora você vai ver como os arrays bidimensionais realmente são por dentro. Pronto?

Arrays bidimensionais são, na verdade, arrays de arrays!

Em outras palavras, se no caso de um array comum “a variável-array armazena uma referência a um contêiner que guarda os elementos do array”, no caso dos arrays bidimensionais a situação é um pouco mais explosiva: a variável-array-bidimensional armazena uma referência a um contêiner que guarda referências a arrays unidimensionais. É melhor ver uma vez do que tentar explicar cem vezes:

À esquerda temos a “variável-array-bidimensional”, que armazena uma referência ao “objeto-array bidimensional”. No meio temos o “objeto array bidimensional”, em cujas células ficam referências a arrays unidimensionais — as linhas do array bidimensional. E, à direita, você vê quatro arrays unidimensionais — as linhas do nosso array bidimensional.

É assim que os arrays bidimensionais são de fato estruturados. E essa abordagem dá ao programador Java algumas vantagens:

Em primeiro lugar, como o “contêiner de contêineres” guarda referências para os “arrays-linha”, podemos trocar as linhas de lugar de forma muito rápida e simples. Para acessar o “contêiner de contêineres”, basta informar um índice em vez de dois. Exemplo:

int[][] data = new int[2][5];
int[] row1 = data[0];
int[] row2 = data[1];

Com esse código é possível trocar as linhas de lugar:

// Matriz importante com dados
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {5, 4, 3, 2, 1}
};

int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;

Se você acessa uma célula de um array bidimensional, mas após o nome do array informa apenas um índice, estará acessando o contêiner de contêineres, em cujas posições ficam as referências para arrays unidimensionais.

6. Imprimindo um array bidimensional na tela

Para imprimir uma tabela bidimensional normalmente se usa um laço duplo — é como desenhar um labirinto no console. Exemplo:

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(); // quebra de linha
}

Exemplo de saída:

1	2	3	4	
5	6	7	8	
9	10	11	12	

Aliás, aqui você aprendeu a “desenhar” tabelas bonitas com apenas algumas linhas de código!