matrizes irregulares em java

1. Matrizes irregulares

Como programador Java, você pode não apenas trocar as linhas de um array bidimensional, mas também construir um array como quiser.

Digamos que você deseja que a primeira linha de uma matriz bidimensional tenha um comprimento de 10, e deseja que o comprimento da segunda linha seja 50. Podemos fazer isso? Sim, nós podemos.

Primeiro, precisamos criar um 'container de containers' — este é o primeiro array, que armazenará referências a arrays de linhas. Assim que se faz:

int[][] name = new int[height][];

Você simplesmente omite a segunda dimensão e a máquina Java cria um contêiner de contêineres. Isto é o que ficará na memória após a execução deste código:

E, bem, você já sabe como criar arrays unidimensionais 🙂

É assim que o código resultante ficará:

// Matrix of important data
int[][] matrix = new int[2][];
matrix[0] = new int[10];
matrix[1] = new int[50]

Acabamos de criar o chamado " array jagged ".

E se agora quisermos exibir todos os elementos desse array na tela, então a lengthpropriedade do array será útil: afinal, os comprimentos das linhas do array são diferentes.

A propósito, como você encontra o comprimento de um 'contêiner de contêineres' em nosso exemplo? Também é um objeto de matriz, o que significa que tem um comprimento. A resposta correta é matrix.length.

E quanto aos arrays que compõem nossas linhas?matrix[0].length

2. Trabalhando com uma matriz bidimensional

Suponha que você queira exibir uma matriz bidimensional. Como você faz isso?

Nosso código ficará mais ou menos assim:

int[][] matrix = new int[3][];
matrix[0] = new int[]{1, 2, 3, 4, 5, 6};
matrix[1] = new int[]{1, 2, 3};
matrix[2] = new int[]{1};
for (int i = 0; i < matrix.length; i++) {
   for (int j = 0; j < matrix[i].length; j++)
      System.out.print( matrix[i][j] + " " );
   System.out.println();
}

Você precisa de dois loops aninhados. O primeiro chamamos de externo e o segundo de interno .

No loop externo (a ivariável), passamos sequencialmente por todas as linhas (arrays) que compõem nosso array bidimensional. Cada valor de icorresponde a uma linha com esse índice.

No loop interno (a jvariável), iteramos sobre todas as células nas linhas. Graças ao loop interno, uma linha, que consiste nos valores de uma matriz unidimensional, será exibida na tela.

Isto é o que será exibido:

1 2 3 4 5 6

1 2 3 4 5 6
1 2 3

1 2 3 4 5 6
1 2 3
1

3. Matrizes multidimensionais

Mais um fato interessante sobre arrays, que você provavelmente já adivinhou. Se você pode fazer um array bidimensional, então você pode fazer um array tridimensional?

Sim, você pode criar um array de qualquer dimensão. Tais matrizes são chamadas de 'multidimensionais'.

Apenas por diversão, vamos criar um array multidimensional com 4 dimensões.

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

Este código é muito simples, não é?

E se você criá-lo manualmente?

int[][][][] matrix;
matrix = new int[2][][][];                // Create a 2-element array of references to references to references
for (int i = 0; i < matrix.length; i++)
{
  matrix[i] = new int[3][][];                // Create a 3-element array of references to references
  for (j = 0; j < matrix[i].length; j++)
  {
    matrix[i][j] = new int[4][];             // Create a 4-element array of references
    for (k = 0; k < matrix[i][j].length; k++)
      matrix[i][j][k] = new int[5];          // Create 5-element arrays of integers
  }
}

E isso é apenas criar o array! Então você também precisa trabalhar com isso de alguma forma.

Tarefa bônus: escrever código que exiba todos os valores em uma matriz tridimensional.