Matrizes multidimensionais

• Matrizes multidimensionais, sintaxe geral
• Matrizes bidimensionais
• Declarando, criando e inicializando arrays bidimensionais
• Exibindo uma matriz bidimensional na tela
• Saída rápida de uma matriz bidimensional
• “Comprimentos” de uma matriz bidimensional
• Exemplo de uso de uma matriz bidimensional: tabuleiro de damas
• Exemplo de uso de uma matriz bidimensional: multiplicação de matrizes
• Matrizes bidimensionais não retangulares
• Matrizes tridimensionais
• Matrizes multidimensionais no trabalho real de um programador Java
• Problemas interessantes em matrizes bidimensionais e tridimensionais

O que é um array Java unidimensional?

Uma matriz é um conjunto ordenado de elementos do mesmo tipo, primitivo ou referência. Informações gerais sobre arrays (principalmente unidimensionais) podem ser encontradas no artigo “ Arrays em Java ” e no curso JavaRush . Neste artigo falaremos sobre arrays cujos elementos são outros arrays. Essas matrizes são chamadas multidimensionais. Uma matriz cujos elementos são outras matrizes, ou seja, uma matriz de matrizes, é chamada de bidimensional. Nem todas as linguagens possuem arrays multidimensionais estruturados dessa forma, mas em Java é esse o caso.

Matrizes Multidimensionais Java, Sintaxe Geral

Em geral, os arrays multidimensionais em Java são assim:

Data_type[dimension1][dimension2][]..[dimensionN] array_name = new data_type[size1][size2]….[sizeN];

Onde Data_typeestá o tipo de elementos na matriz. Pode ser primitivo ou referência (classe). O número de pares de colchetes dimensiondentro é a dimensão do array (no nosso caso - N). array_name— nome do array size1...sizN— número de elementos em cada dimensão do array. Declarando matrizes multidimensionais:

int[][] twoDimArray; //two-dimensional array
String[][][] threeDimArray; //three-dimensional array
double[][][][][] fiveDimArray; // five-dimensional array

Talvez tudo isso pareça muito abstrato, então agora vamos passar para as manifestações concretas de matrizes multidimensionais - bidimensionais e tridimensionais. O fato é que os desenvolvedores Java às vezes usam matrizes bidimensionais, com muito menos frequência - matrizes tridimensionais, e matrizes ainda maiores são extremamente raras. Há uma grande probabilidade de você não os encontrar.

O que é um array Java bidimensional?

Um array bidimensional em Java é um array de arrays, ou seja, cada célula contém uma referência a um array. Mas é muito mais fácil apresentá-lo na forma de uma tabela que possui um determinado número de linhas (primeira dimensão) e número de colunas (segunda dimensão). Uma matriz bidimensional em que todas as linhas possuem um número igual de elementos é chamada de retangular.

Declarando, criando e inicializando arrays bidimensionais

O procedimento para declarar e criar um array bidimensional é quase o mesmo que no caso de um array unidimensional:

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

Esta matriz possui 3 linhas e 4 colunas. O tamanho de um array bidimensional retangular (podem não ser retangulares, mais sobre isso abaixo), ou seja, o número total de elementos pode ser determinado multiplicando o número de linhas pelo número de colunas. Agora está inicializado (preenchido) com valores padrão. Ou seja, zeros. Vamos preenchê-lo com os valores que precisamos.

twoDimArray[0][0] = 5;//write the value 5 into the cell at the intersection of the zero row and zero column
twoDimArray[0][1] = 7; //write the value 7 into the cell at the intersection of the zero row and the first column
twoDimArray[0][2]  = 3;
twoDimArray[0][3] = 17;
twoDimArray[1][0] = 7;
twoDimArray[1][1] = 0;
twoDimArray[1][2] = 1;
twoDimArray[1][3] = 12;
twoDimArray[2][0] = 8;
twoDimArray[2][1] = 1;
twoDimArray[2][2] = 2;
twoDimArray[2][3] = 3;

Tal como acontece com matrizes unidimensionais, você pode executar o procedimento de inicialização mais rapidamente:

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};

Em ambos os casos, obteremos um array bidimensional com três linhas e quatro colunas, preenchido com números inteiros.

Exibindo uma matriz bidimensional na tela

A maneira mais lógica de fazer esta operação é primeiro gerar a linha zero elemento por elemento, depois o segundo e assim por diante. A maneira mais comum de gerar um array bidimensional em Java é usar dois loops aninhados.

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};//declared an array and filled it with elements
for (int i = 0; i < 3; i++) {  //go through the lines
            for (int j = 0; j < 4; j++) {//go through the columns
                System.out.print(" " + twoDimArray[i][j] + " "); //output element
            }
            System.out.println();// line wrap for the visual preservation of the tabular form
        }

Saída rápida de uma matriz bidimensional

A maneira mais curta de exibir uma lista de elementos de um array bidimensional na tela é usar o método deepToStringde classe Arrays. Exemplo:

int[][] myArray = {{18,28,18},{28,45,90},{45,3,14}};
System.out.printLn(Arrays.deepToString(myArray));

O resultado do programa é a seguinte saída: [[18, 28, 18], [28, 45, 90], [45, 3, 14]]

“Comprimentos” de uma matriz bidimensional

Para obter o comprimento de um array unidimensional (ou seja, o número de elementos nele), você pode usar a variável length. Ou seja, se definirmos um array int a[] = {1,2,3}, então a operação a.lengthretornará 3. Mas e se aplicarmos o mesmo procedimento ao nosso array bidimensional?

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};
System.out.println(twoDimArray.length);

Saída: 3 Portanto, esta operação gera o número de linhas na matriz. Como obter o número de colunas? Se estamos lidando com matrizes bidimensionais retangulares (ou seja, aquelas em que todas as linhas têm o mesmo comprimento), podemos aplicar a operação twoDimArray[0].lengthou em vez do elemento zero (essencialmente a linha zero) - qualquer outro existente. Podemos fazer isso porque em Java, um array bidimensional é um array de arrays e o elemento zero twoDimArray[0]é um array de comprimento 4. Você mesmo pode verificar isso.

Exemplo de uso de uma matriz bidimensional: tabuleiro de damas

Matrizes bidimensionais podem ser usadas para criar qualquer campo bidimensional finito, por exemplo, em jogos e, em particular, no xadrez. É fácil pensar em um tabuleiro de xadrez como uma matriz bidimensional. Você pode “anexar” gráficos a isso, mas por enquanto, vamos definir um tabuleiro de xadrez usando símbolos e enviá-lo para o console. O quadrado inferior esquerdo do tabuleiro de xadrez é pintado de preto, o próximo é branco, assim como o que está acima dele. Portanto, a cor muda toda vez que você passa para uma célula adjacente ao lado. Para definir a coloração do xadrez não manualmente, mas usando um algoritmo, você pode usar uma verificação de paridade: se a soma do índice da linha e da coluna for par ou zero, a célula será branca, caso contrário, será preta. Para esta verificação, usamos o operador restante% no algoritmo. Como não estamos trabalhando com gráficos, mas com símbolos, denotaremos a célula branca com a letra W(branco) e a célula preta com a letra B(preto).

//set the chessboard as a two-dimensional array
String [][] chessBoard = new String[8][8];
        for (int i = 0; i< chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W";
                else chessBoard[i][j] = "B";
            }
        }

A saída do programa é a seguinte: WBWBWBWBBWBWBWBWWBWBW BWBBWBWBWBWWBWBWBWBBW BWBWBWWBWBWBWBBWBWBWB W Tudo é como em um tabuleiro de xadrez real, você pode conferir. Agora vamos escrever um método para numerar células corretamente, não na linguagem de arrays, mas na linguagem de “xadrez”. A célula inferior esquerda do quadro é chamada A1, enquanto em nosso array é chessBoard[7][0]. Vamos associar cada par de índices de um array bidimensional ao seu equivalente “xadrez”. Para fazer isso, usamos duas linhas - " abcdefgh" e " 87654321" (na ordem inversa - para simplificar, para que o tabuleiro de xadrez 8 corresponda à coluna zero).

public static String chessBoardCoord(int a, int b) {
            String letters = "abcdefgh";
            String numbers = "87654321";
            if ((a > 7)|| (b>7)) return null; //if the number is outside the board, return the default value - null
            else return (Character.toString(letters.charAt(a)) + numbers.charAt(b)); /*charAt - a method with which we extract from the string the element under the passed number, here - under the numbers a and b. Character.toString - a method that converts the received character into a string */
        }

Agora vamos exibir em cada célula não apenas sua cor, mas também seu número, usando o métodochessBoardCoord

String [][] chessBoard = new String[8][8];
        for (int i = 0; i < chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W" + chessBoardCoord(j,i);
                else chessBoard[i][j] = "B"+ chessBoardCoord(j,i);
            }
        }

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

Saída do programa: Wa8 Bb8 Wc8 Bd8 We8 Bf8 Wg8 Bh8 Ba7 Wb7 Bc7 Wd7 Be7 Wf7 Bg7 Wh7 Wa6 Bb6 Wc6 Bd6 We6 Bf6 Wg6 Bh6 Ba5 Wb5 Bc5 Wd5 Be5 Wf5 Bg5 Wh5 Wa4 Bb4 Wc4 Bd4 We4 Bf4 Wg4 Bh4 Ba3 Wb3 Bc3 Wd 3Be3 Wf3 Bg3 Wh3 Wa2 Bb2 Wc2 Bd2 We2 Bf2 Wg2 Bh2 Ba1 Wb1 Bc1 Wd1 Be1 Wf1 Bg1 Wh1 Onde We2significa o quadrado branco numerado e2.

Exemplo de uso de uma matriz bidimensional: multiplicação de matrizes

Atenção!Este exemplo requer conhecimento básico de matrizes. Aqui muito pouco será dito sobre eles, e esta informação é destinada àqueles que estudaram, mas um tanto esqueceram, aritmética matricial. No entanto, este conhecimento pode ser obtido a partir de fontes abertas, em particular de um artigo na Wikipédia . Este é um bom exemplo de uso de arrays bidimensionais, mas podemos seguir em frente sem ele. Portanto, se agora parece incompreensível para você do ponto de vista matemático e você realmente não deseja se aprofundar no assunto, sinta-se à vontade para pular o exemplo. Se você estudou álgebra linear básica, pode ter aprendido sobre matrizes retangulares como matrizes retangulares. Onde a11, a12... aNN são alguns números. Na figura, a matriz nem é retangular, mas quadrada (o número de linhas é igual ao número de colunas, mas nem sempre é assim). Na vida real, essas matrizes raramente são encontradas, mas na programação e na ciência da computação elas são muito comuns. Em particular, eles são usados ​​em computação gráfica e motores de jogos. Por exemplo, a rotação de um objeto na tela em qualquer ângulo pode ser programada usando uma matriz de rotação. No espaço bidimensional, a matriz de rotação se parece com isto: Onde theta é o ângulo através do qual o objeto precisa ser girado. Matrizes de dimensões iguais podem ser somadas entre si, e a adição ocorre elemento por elemento (adicionamos elementos com os mesmos índices). Mas a operação de multiplicação de matrizes é menos familiar. Assim, as matrizes podem ser multiplicadas e uma matriz resultante só pode ser obtida se o número de colunas da primeira matriz coincidir com o número de linhas da segunda. A matriz resultante terá o mesmo número de linhas que a primeira e o mesmo número de colunas que a segunda. A multiplicação é realizada da seguinte maneira. Vamos ter uma matriz a[l][m]e b[m][n]. Como resultado de sua multiplicação, devemos obter uma matriz c[l][n]. Para obter um elemento de c[0][0]uma matriz de produto, você precisa a[0][0]multiplicar o elemento zero da linha zero da primeira matriz pelo elemento zero da segunda matriz e, em seguida, multiplicar o primeiro elemento da primeira linha da primeira matriz pelo primeiro elemento da primeira coluna da segunda matriz, e assim por diante, após o que todos os produtos resultantes são somados.

a[0][0]*b[0][0] + a[0][1]*b[1][0] + … + a[0][m-1]*b[m-1][0]

Para obter o segundo elemento da primeira linha da matriz resultado, realizamos o mesmo procedimento com a segunda linha

a[1][0]*b[0][0] + a[1][1]*b[0][1] + … + a[0][m-1]*b[m-1][0]

E assim sucessivamente até o fim da linha. Em seguida, passamos para a próxima linha e repetimos o procedimento até ficar sem linhas. Ou seja, multiplicamos as linhas da primeira matriz pelas colunas da segunda matriz. Abaixo está o código para multiplicação de matrizes. Você pode complementá-lo com uma verificação do cumprimento da condição acima mencionada sobre o número de linhas e colunas.

//declaring two matrices
int [][] twoDimArray1 = {{1,0,0,0},{0,1,0,0},{0,0,0,0}};
int[][] twoDimArray2 = {{1,2,3},{1,1,1},{0,0,0},{2,1,0}};

//matrix multiplication process
int[][]twoDimArray3 = new int [twoDimArray1.length][twoDimArray2[0].length];
        for (int i=0; i<twoDimArray3[0].length; i++)
            for (int j=0; j<twoDimArray3.length; j++)
                for (int k=0; k<twoDimArray1[0].length; k++)
                              twoDimArray3[i][j] = twoDimArray3[i][j] + twoDimArray1[i][k] * twoDimArray2[k][j];

//output on display
        for (int i = 0; i < twoDimArray3.length; i++) {
            for (int j = 0; j < twoDimArray3[0].length; j++) {
                System.out.print(" " + twoDimArray3[i][j] + " ");
            }
            System.out.println();
        }

O programa gera o seguinte resultado: 1 2 3 1 1 1 0 0 0

Matrizes bidimensionais não retangulares

Como os arrays bidimensionais em Java são arrays de arrays, cada um dos arrays internos pode ter comprimentos diferentes. Ao criar um array, podemos especificar apenas o número de linhas e não o número de colunas (ou seja, o comprimento dessas mesmas linhas). Vejamos um exemplo.

//declaring and creating an array, specifying only the number of rows
int [][] twoDimArray = new int[5][];

//initialize the array, filling it with arrays of different lengths
        twoDimArray[0] = new int[]{1, 2, 3, 4, 5};
        twoDimArray[1] = new int[]{1,2,3,4};
        twoDimArray[2] = new int[]{1,2,3};
        twoDimArray[3] = new int[]{1,2};
        twoDimArray[4] = new int[]{1};
//display the resulting non-rectangular two-dimensional array on the screen
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                System.out.print(" " + twoDimArray[i][j] + " ");
            }
            System.out.println();
        }

Saída do programa: 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1 Assim, a linha zero do nosso array contém o array {1,2,3,4,5}e a quarta linha contém o array {1}.

Matrizes tridimensionais em Java

Seguindo o bom senso e a lógica da linguagem Java, um array tridimensional pode ser chamado de “array de arrays de arrays” ou “um array cujo cada elemento é um array bidimensional”. Além disso, essas matrizes bidimensionais podem ser diferentes. Exemplo:

// create a three-dimensional array consisting of two two-dimensional arrays
int[][][] threeDimArr = new int[2][][];
//create the first 2D array of a 5x2 3D array
        threeDimArr[0] = new int[5][2];
//create a second 2D array of a 1x1 3D array
        threeDimArr[1] = new int[1][1];

Porém, mais frequentemente, na prática, existem matrizes tridimensionais nas quais todas as três quantidades são definidas ao mesmo tempo, um análogo das matrizes bidimensionais retangulares. Como já mencionamos, arrays tridimensionais ou mais raramente são usados. No entanto, você pode programar algo interessante com um array 3D. Por exemplo, um estacionamento de vários andares. Cada andar pode ser considerado uma matriz bidimensional, e uma vaga de estacionamento pode ser considerada um elemento específico de uma matriz tridimensional. Um elemento de tal array pode ser representado por um tipo booleancom valor falso se o espaço estiver livre e verdadeiro se o espaço estiver ocupado.

//set a boolean three-dimensional array. This car park has 3 floors, each of which can accommodate 2x5 = 10 cars. By default, all cells are empty (false)
boolean[][][] parkingLot = new boolean[3][2][5];
//two cars arrived and parked on the ground floor in cell [1][0] and [1][3]
        parkingLot[0][1][0] = true;
        parkingLot[0][1][3] = true;

//Output the array to the console
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 5; k++) {
                    System.out.print("arr[" + i + "][" + j + "][" + k + "] = " + parkingLot[i][j][k] + "\t");

                }
                System.out.println();
            }
        }

Problemas interessantes em matrizes bidimensionais e tridimensionais

Você sabe o suficiente sobre arrays multidimensionais em Java e, se se sentir confiante, pode tentar resolver alguns dos problemas abaixo. Eles não são fáceis, mas interessantes. Jogo da velha. Monte um campo 3x3, crie dois jogadores que se revezam. Inicialmente o campo está vazio, e em cada um dos campos vazios o primeiro jogador pode colocar uma cruz e o segundo um zero. O vencedor é aquele que primeiro coletar três cruzes ou três zeros dispostos em uma linha, uma coluna ou na diagonal. Formiga de Langton . Existe um determinado campo, dividido em células (uma matriz bidimensional), pintadas de preto ou branco (pode ser definido por uma função aleatória). Uma “formiga” se materializa aleatoriamente em uma das células e, a cada passo, pode se mover em uma das quatro direções até a célula adjacente, horizontal ou verticalmente. Regras de movimento das formigas:

• Num quadrado preto, a formiga deve virar 90° para a esquerda, mudar a cor da sua célula para branca e depois avançar para o próximo quadrado.
• Em um quadrado branco, a formiga gira 90° para a direita e muda a cor de sua célula para preto, depois avança para o próximo quadrado.

Escreva um método que calcule a iteração no número do passo ndada a posição inicial da formiga. O campo pode ser preenchido aleatoriamente com zeros e uns (ou indicado pelas letras We B, como fizemos no exemplo do tabuleiro de xadrez). Também precisamos de mais dois parâmetros - a posição horizontal e vertical da formiga, bem como sua direção nesta etapa (norte, sul, oeste, leste), enquanto por padrão a formiga olha para o norte. Você pode tentar modelar um cubo de Rubik usando matrizes tridimensionais. Um cubo de Rubik padrão tem 6 faces e cada uma delas é uma matriz tridimensional de quadrados coloridos Color[][][] rubik = new Color[6][3][3]. Contudo, implementar um cubo de Rubik não é uma tarefa trivial.

Materiais úteis sobre matrizes

Muitos artigos sobre JavaRush são dedicados a arrays (principalmente unidimensionais, pois são usados ​​​​com muito mais frequência na prática). Preste atenção a eles.

1. Matrizes em Java - sobre matrizes para iniciantes com exemplos
2. Something About Arrays – Bom artigo detalhado sobre arrays
3. A classe Arrays e seu uso – o artigo descreve alguns métodos da classeArray
4. Arrays é a primeira palestra JavaRush dedicada a arrays.
5. Retorne uma matriz de comprimento zero, não nula - o autor de Programação Eficaz, Joshua Bloch, fala sobre como retornar melhor matrizes vazias