Matrizes bidimensionais

Um trecho de palestra com um mentor como parte do curso Codegym University. Inscreva-se no curso completo.

"Saudações, Amigo!"

"Olá, Rishi!"

"Você já sabe uma ou duas coisas sobre arrays e até conseguiu resolver algumas tarefas, espero. Mas você não sabe tudo. Por exemplo, aqui está outro fato interessante sobre arrays. Arrays não são apenas unidimensionais (linear ). Eles também podem ser bidimensionais."

"Hum... O que isso significa?"

"Isso significa que as células da matriz podem representar não apenas uma coluna (ou linha), mas também uma tabela retangular.

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

"Onde name é o nome da variável do array, width é a largura da tabela (em células) e height é a altura da tabela. Veja um exemplo:

int[][] data = new int[2][5];
data[1][1] = 5;

"É assim que ficará na memória:

"A propósito, para arrays bidimensionais, você também pode usar inicialização rápida:

// Lengths of months of the year in each quarter
int[][] months = { {31, 28, 31}, {30, 31, 30}, {31, 31, 30}, {31, 30, 31} };

"Hmm... isso é interessante. Se imaginarmos que no primeiro parênteses internos representa um elemento, o próximo é um segundo... Então um array bidimensional é como um array de arrays?"

"Que aluno inteligente você é! Exatamente. O primeiro elemento é o array unidimensional {31, 28, 31}, o segundo é {30, 31, 30}, e assim por diante. Mas voltaremos a isso um pouco mais tarde nesta lição. Até então, tente pensar em uma matriz bidimensional como uma tabela com linhas e colunas, formando células em cada interseção.

"Tenho uma imagem mental disso. A propósito, para que servem esses arrays bidimensionais?"

"Os programadores precisam de matrizes bidimensionais com bastante frequência. Se você olhar de perto, quase todos os jogos de tabuleiro são implementados usando uma matriz bidimensional pronta para uso: xadrez, damas, jogo da velha, batalha naval, etc.:"

"Entendi! O campo de jogo de xadrez ou batalha naval se encaixa perfeitamente em matrizes bidimensionais!"

"Sim, mas você precisa usar números como as coordenadas da célula. Não 'peão e2-e4', mas 'peão (5,2) -> (5,4)'. Será ainda mais fácil para você como programador. "

Organizando elementos em arrays: (x, y) ou (y, x)

"Criar arrays bidimensionais levanta um dilema interessante. Quando criamos um array usando new int [2][5];, temos uma tabela de 'duas linhas e 5 colunas ' ou 'duas colunas e 5 linhas'?"

"Em outras palavras, não está totalmente claro se estamos especificando primeiro a largura e depois a 'altura... ou vice-versa, primeiro a altura e depois a largura?"

"Sim, esse é o dilema. E não há uma resposta definitiva."

"O que fazer?"

"Primeiro, é importante entender como nossa matriz bidimensional é realmente armazenada na memória . Naturalmente, a memória do computador não contém nenhuma tabela: cada local na memória possui um endereço numérico sequencial: 0, 1, 2, ... Para nós, esta é uma tabela 2 × 5, mas na memória são apenas 10 células, nada mais. Sem divisão em linhas e colunas."

"Eu entendi. Como então determinamos qual dimensão vem primeiro - a largura ou a altura?"

"Vamos considerar a primeira opção. Largura primeiro, depois altura . " e depois 'y' (a dimensão vertical). E este não é apenas um padrão escolar – é um padrão geralmente aceito em matemática. Como dizem, você não pode discutir com a matemática."

"É mesmo? Bem, se não podemos lutar contra isso, então primeiro a largura e depois a altura?"

"Existe um argumento interessante a favor de 'altura primeiro, depois largura' . Esse argumento vem da inicialização rápida de arrays bidimensionais. Afinal, se quisermos inicializar nosso array, então escrevemos um código como este:"

// Matrix of important data
int[][] matrix = { {1, 2, 3, 4, 5}, {1, 2, 3, 4, 5} };

"Então, o que isso faz por nós?"

"Você notou alguma coisa? E se tivermos isso?

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {1, 2, 3, 4, 5}
};

"Se escrevermos nossos dados no código linha por linha, obteremos uma tabela com 2 linhas e 5 colunas."

"Agora entendo. 2 é a altura e 5 é a largura... Então, qual opção devemos usar?"

"Cabe a você decidir o que é mais conveniente. O mais importante é que todos os programadores que trabalham no mesmo projeto sigam a mesma abordagem."

"Se você trabalha em um projeto cujo código possui muitos arrays bidimensionais inicializados, provavelmente tudo ali será baseado na inicialização rápida de dados, ou seja, você terá o padrão 'altura x largura'.

"Se você se encontrar em um projeto envolvendo muita matemática e trabalhando com coordenadas (por exemplo, mecanismos de jogos), o código provavelmente adotará a abordagem 'largura x altura'.

Como as matrizes bidimensionais são organizadas

"Agora, você se lembra do recurso especial de arrays bidimensionais que você notou no início da lição?"

"Sim! Acontece que arrays bidimensionais são na verdade arrays de arrays!"

"Exatamente. "Em outras palavras, se no caso de um array comum uma variável de array armazena uma referência a um container que armazena elementos de array, então no caso de arrays bidimensionais a situação explode um pouco: um array bidimensional A variável -array armazena uma referência a um contêiner que armazena referências a matrizes unidimensionais. É melhor vê-lo em ação uma vez do que tentar explicá-lo centenas de vezes:"

"À esquerda , temos uma variável array bidimensional, que armazena uma referência a um objeto array bidimensional. No meio há um objeto array bidimensional cujas células armazenam arrays unidimensionais, que são os linhas de um array bidimensional. E à direita , você pode ver quatro arrays unidimensionais — as linhas de nosso array bidimensional. É assim que os arrays bidimensionais realmente funcionam."

"Fantástico! Mas o que isso nos dá?"

"Como um 'contêiner de contêineres' armazena referências a 'arrays de linhas', podemos trocar as linhas de maneira muito rápida e fácil. Para obter um 'contêiner de contêineres', basta especificar um índice em vez de dois. Exemplo:

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

"Veja o código abaixo. Podemos usá-lo para trocar linhas:"

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {5, 4, 3, 2, 1}
};

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

{
  {5, 4, 3, 2, 1},
  {1, 2, 3, 4, 5}
};

"Entendi. Funciona como trocar quaisquer dois itens comuns."

"Sim. Bem, se você se referir a uma célula de uma matriz bidimensional, mas especificar apenas um índice após o nome da matriz, estará se referindo a um contêiner de contêineres cujas células armazenam referências a um- matrizes dimensionais."

"Tudo parece lógico e claro. Obrigado pela palestra, Rishi!"

"De nada. Coloque-o em prática com sabedoria."