Arrays irregulares (Jagged Arrays)

1. Arrays irregulares são diferentes dos bidimensionais

Chegamos ao tópico que muitos chamam de “arrays irregulares” — em inglês, jagged arrays. Diferentemente dos arrays bidimensionais, arrays irregulares permitem armazenar linhas de comprimentos diferentes. É como ter um conjunto de prédios, cada um com sua própria quantidade de apartamentos — em um prédio há 5 apartamentos, em outro 20, e no terceiro — apenas um.

Array irregular é um array em que cada elemento é um array, e esses arrays internos (também chamados de “subarrays”) podem ter comprimentos diferentes.

Principal diferença:

• Em um array bidimensional, cada “linha” (e cada “coluna”) tem a mesma quantidade de elementos. Exemplo: int[][] grid = new int[3][5]; — temos sempre 3 linhas com 5 elementos cada.
• Em um array irregular, cada linha pode ter um comprimento diferente! Exemplo: int[][] jagged = new int[3][]; — e só depois inicializamos cada linha (subarray) à sua maneira.

Veja como fica visualmente:

Array bidimensional (3x3):
┌───┬───┬───┐
│ 1 │ 2 │ 3 │
├───┼───┼───┤
│ 4 │ 5 │ 6 │
├───┼───┼───┤
│ 7 │ 8 │ 9 │
└───┴───┴───┘

Array irregular (comprimentos diferentes):
┌───┬───┐
│ 1 │ 2 │
├───┼───┼───┬───┐
│ 3 │ 4 │ 5 │ 6 │
├───┼───┴───┴───┘
│ 7 │
└───┘

2. Sintaxe de declaração e inicialização de um array irregular

Declarar um array irregular não é mais assustador do que declarar os tipos anteriores! Não tenha medo dos colchetes duplos:

int[][] jaggedArray = new int[3][];

Isso significa que temos um array de 3 elementos, e cada um deles também é um array de int. Mas, por enquanto, os arrays internos não foram criados! Para entender melhor, vamos detalhar isso.

Inicialização passo a passo de um array irregular

Etapa 1 — criação do array principal (externo):

int[][] jaggedArray = new int[3][];

Agora temos 3 “linhas”, mas todas elas ainda são null.

Etapa 2 — criação e preenchimento dos arrays internos (subarrays):
Por exemplo, a primeira linha terá comprimento 2, a segunda — 4, a terceira — 3:

jaggedArray[0] = new int[2]; // 2 elementos na primeira linha
jaggedArray[1] = new int[4]; // 4 elementos na segunda linha
jaggedArray[2] = new int[3]; // 3 elementos na terceira linha

Etapa 3 — preenchimento com valores:
Os arrays internos são arrays comuns! Por exemplo:

jaggedArray[0][0] = 1;
jaggedArray[0][1] = 2;

jaggedArray[1][0] = 3;
jaggedArray[1][1] = 4;
jaggedArray[1][2] = 5;
jaggedArray[1][3] = 6;

jaggedArray[2][0] = 7;
jaggedArray[2][1] = 8;
jaggedArray[2][2] = 9;

Inicialização curta de um array irregular

Você pode criar e preencher um array irregular de uma vez, se já souber os valores:

int[][] jaggedArray = new int[][]
{
    new int[] { 1, 2 },
    new int[] { 3, 4, 5, 6 },
    new int[] { 7, 8, 9 }
};

Ou um pouco mais curto, omitindo o tipo dos arrays internos:

int[][] jaggedArray = 
{
    { 1, 2 },
    { 3, 4, 5, 6 },
    { 7, 8, 9 }
};

3. Iteração e trabalho com arrays irregulares

Iterar um array irregular não é mais difícil do que um bidimensional, mas agora o laço externo percorre as linhas e o interno os elementos da linha (que podem ter comprimentos diferentes):

for (int i = 0; i < jaggedArray.length; i++) 
{
    System.out.println("Linha " + i + ":");
    for (int j = 0; j < jaggedArray[i].length; j++) 
    {
        System.out.print(jaggedArray[i][j] + " ");
    }
    System.out.println();
}

Resultado na tela:

Linha 0:
1 2 
Linha 1:
3 4 5 6 
Linha 2:
7 8 9 

Você pode usar for-each para não se preocupar com índices:

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

4. Cenários típicos de uso dos arrays irregulares

Quando um array irregular pode ser mais útil do que um bidimensional?

• Se você armazena para cada usuário uma quantidade diferente de dados: notas por disciplina, compras, comentários e assim por diante.
• Se seus dados têm uma estrutura triangular ou em degraus (por exemplo, para imprimir pirâmides, triângulos de Pascal etc.).
• Se deseja economizar memória: em um array bidimensional, todas as linhas são fixas, e no irregular — apenas a quantidade necessária de elementos.

Exemplo do dia a dia: gerenciador de notas dos estudantes

Suponha que temos três estudantes e aqui estão suas notas por diferentes tarefas de matemática:

Vamos declarar esse array:

int[][] studentMarks = new int[3][];
studentMarks[0] = new int[] { 5, 4 };         // Primeiro estudante — 2 notas
studentMarks[1] = new int[] { 3, 4, 4 };      // Segundo estudante — 3 notas
studentMarks[2] = new int[] { 5 };            // Terceiro estudante — 1 nota

Vamos exibir as notas de cada estudante:

for (int i = 0; i < studentMarks.length; i++) 
{
    System.out.print("Estudante " + i + ": ");
    for (int j = 0; j < studentMarks[i].length; j++) 
    {
        System.out.print(studentMarks[i][j] + " ");
    }
    System.out.println();
}

Usando arrays irregulares com outros tipos

Um array irregular pode ser de qualquer coisa: strings, arrays de outros arrays (mais profundo!), até seus próprios objetos.

Exemplo: array de strings

String[][] groups = {
    { "Ivan", "Pyotr" },
    { "Maria", "Alexey", "Sergey" },
    { "Vasilisa" }
};

5. Arrays tridimensionais e multidimensionais

E mais um fato interessante sobre arrays, que você provavelmente já suspeita. Se é possível fazer um array bidimensional, então dá para fazer um tridimensional?

Sim, é possível criar arrays de qualquer dimensionalidade. Esses arrays são chamados de multidimensionais.

Como declarar arrays multidimensionais

Basta listar a quantidade necessária de dimensões entre colchetes:

int[][][] cube = new int[2][3][4]; // 2 "camadas", 3 linhas, 4 colunas
cube[0][1][2] = 99;

Aqui temos um array tridimensional:

• 2 elementos na primeira coordenada,
• 3 — na segunda,
• 4 — na terceira.

Tal array é um grande “cubo” de dados, empacotado sequencialmente.

Iterando um array tridimensional

O acesso a um elemento é feito usando todos os índices de uma vez:

for (int i = 0; i < cube.length; i++) 
{
    for (int j = 0; j < cube[i].length; j++) 
    {
        for (int k = 0; k < cube[i][j].length; k++) 
        {
            System.out.print(cube[i][j][k] + " ");
        }
        System.out.println();
    }
    System.out.println("---");
}

• Os índices começam em zero, como sempre em Java.
• Ao todo, esse array terá 2 × 3 × 4 = 24 elementos.

Exemplos práticos de arrays multidimensionais

• 2D — tabelas, tabuleiros de xadrez, imagens.
• 3D — “cubinhos” em computação gráfica, dados para cálculos científicos (por exemplo, temperatura em diferentes pontos no espaço e tempo).
• 4D e acima — raramente usados, mas aparecem em matemática avançada, simulações, aprendizado de máquina etc.

6. Erros típicos ao trabalhar com arrays multidimensionais

Erro nº 1: acesso fora dos limites do array

O erro mais comum — tentar acessar um elemento inexistente, por exemplo:

int[][] arr = new int[2][3];
arr[2][0] = 5; // Erro! Não há linha com índice 2 (só existem 0 e 1)
arr[0][3] = 7; // Erro! Não há coluna com índice 3 (só existem 0, 1, 2)

Numa chamada dessas, o programa lançará ArrayIndexOutOfBoundsException. Sempre verifique se os índices estão dentro dos limites permitidos: de 0 até length - 1.

Erro nº 2: linhas não inicializadas em um array irregular

Se você criar um array irregular e esquecer de inicializar os arrays internos, ao tentar acessar haverá NullPointerException:

int[][] jagged = new int[3][];
jagged[0][0] = 5; // Erro! jagged[0] == null

Primeiro você precisa criar o array interno: jagged[0] = new int[2];

Erro nº 3: uso incorreto do tamanho do array

Confundir matrix.length (quantidade de linhas) com matrix[0].length (quantidade de colunas). Isso acontece especialmente ao copiar, iterar, somar por colunas.

Erro nº 4: presumir que todas as linhas têm o mesmo comprimento

Em arrays irregulares, as linhas podem ter comprimentos diferentes! Se você escreve matrix[i][j], certifique-se de que j < matrix[i].length.

Erro nº 5: confusão na ordem dos índices

Às vezes confundem que primeiro vem a linha e depois a coluna: matrix[linha][coluna]. Não o contrário!