Matrizes em Java

Imagine armários em uma sala de armazenamento. Cada um deles tem seu próprio número e cada um deles armazena algum objeto Baggage. Ou uma carta de vinhos onde cada tipo de vinho é numerado e você pede dando o número da sua bebida. Ou uma lista de alunos em que "Adams" é registrado na primeira posição e "Zimmer" é o último. Ou uma lista de passageiros em um avião, cada um com um assento numerado. Em Java, arrays são freqüentemente usados ​​para trabalhar com tais estruturas, ou seja, conjuntos de dados homogêneos.

O que é uma matriz?

Uma matriz é uma estrutura de dados que armazena elementos do mesmo tipo. Você pode pensar nisso como um conjunto de células numeradas. Você pode colocar alguns dados em cada célula (um elemento de dados por célula). Uma célula específica é acessada usando seu número. O número de um elemento na matriz também é chamado de índice . Em Java, um array é homogêneo, ou seja, todas as suas células contêm elementos do mesmo tipo. Assim, um array de inteiros contém apenas inteiros ( int ), um array de strings — somente strings, e um array de instâncias de uma classe Dog que criamos conterá apenas objetos Dog . Em outras palavras, Java não nos permite colocar um inteiro na primeira célula do array, uma String na segunda e um Dog na terceira.

Declarando uma matriz

Como declarar um array?

Como qualquer variável, um array deve ser declarado em Java. Isso pode ser feito de um desses dois jeitos. Eles são equivalentes, mas a primeira maneira é mais consistente com o estilo Java. O segundo é um legado da linguagem C: muitos programadores C mudaram para Java e um método alternativo foi mantido para sua conveniência. A tabela mostra as duas maneiras de declarar um array em Java: Em ambos os casos, dataType é o tipo das variáveis ​​na matriz. Nos exemplos, declaramos dois arrays. Um armazenará int s e o outro — objetos Object . Assim, uma declaração de array tem um nome e um tipo (o tipo dos elementos do array). ArrayName é o nome da matriz.

Criando uma matriz

Como você cria uma matriz?

Como qualquer outro objeto, você pode criar um array Java, ou seja, reservar um lugar na memória para ele, usando o operador new . Assim que se faz:

new typeOfArray[length]; 

onde typeOfArray é o tipo do array e length é seu comprimento (ou seja, o número de células) expresso como um número inteiro ( int). Mas observe que aqui apenas alocamos memória para o array — não associamos o array declarado a nenhuma variável declarada anteriormente. Normalmente, um array é primeiro declarado e depois instanciado, por exemplo:

int[] myArray; // Array declaration
myArray = new int[10]; // Create (allocate memory for) an array of 10 ints

Aqui criamos um array de inteiros chamado myArray , informando ao compilador que ele consiste em 10 células (cada uma contendo um inteiro). No entanto, é muito mais comum usar a seguinte sintaxe abreviada para criar um array imediatamente quando ele é declarado:

int[] myArray = new int [10]; // Declare the array and allocate memory "in one blow"

Observe:Depois que uma matriz é criada usando o novo operador, suas células contêm valores padrão. Para tipos numéricos (como em nosso exemplo), o valor padrão é 0, para o tipo booleano é false e para tipos de referência é null . Assim, depois de executar esta declaração

int[] myArray = new int[10];

obtemos uma matriz de dez inteiros e, até que o programa faça algo para alterar os valores, cada célula contém 0.

Comprimento da matriz em Java

Como dissemos acima, o comprimento de um array é o número de elementos que o array foi projetado para conter. O comprimento de uma matriz não pode ser alterado após sua criação. Observeque os elementos da matriz são numerados a partir de zero em Java. Assim, se tivermos um array de 10 elementos, então o índice do primeiro elemento é 0 e o índice do último é 9. Você pode obter o comprimento do array usando a variável length . Por exemplo:

int[] myArray = new int[10]; // Create an int array for 10 elements and name it myArray
System.out.println(myArray.length); // Display the array's length, i.e. the number of elements we can put into the array

Saída:

10

Inicializando um array e acessando seus elementos

Agora sabemos como criar um array em Java. O processo nos dá não uma matriz vazia, mas uma matriz preenchida com valores padrão. Por exemplo, para uma matriz int , é 0 e, se tivermos uma matriz de qualquer tipo de referência, o padrão em cada célula é null . Acessamos um elemento de array (por exemplo, para definir seu valor, exibi-lo na tela ou realizar alguma operação com ele) por seu índice. A inicialização do array é o processo de preenchimento de um array com valores específicos (além do padrão). Exemplo: vamos criar um array de strings para as 4 estações e preenchê-lo com os nomes das estações.

String[] seasons = new String[4]; /* Declare and create an array. Java allocates memory for an array of 4 strings, and each cell is set to null (since String is a reference type) */ 

seasons[0] = "Winter"; /* We set the first cell, i.e. the cell with index zero, to "Winter". Here we access the zeroth element of the array and write a specific value to it. */ 
seasons[1] = "Spring"; // We follow a similar procedure for the cell with index 1 (the second cell)
seasons[2] = "Summer"; // ... index 2
seasons[3] = "Autumn"; // and finally, index 3

Agora os nomes das estações são escritos nas quatro células do nosso array. Poderíamos inicializar o array de uma forma diferente, combinando a declaração e a inicialização:

String[] seasons = new String[] {"Winter", "Spring", "Summer", "Autumn"};

Além disso, o novo operador pode ser omitido:

String[] seasons = {"Winter", "Spring", "Summer", "Autumn"};

Como você exibe uma matriz na tela em Java?

Você pode exibir os elementos do array na tela (ou seja, no console) usando um loop for . Outra maneira mais curta de exibir um array será discutida no parágrafo intitulado " Métodos úteis para trabalhar com arrays ". Enquanto isso, dê uma olhada neste exemplo em que uma matriz é exibida usando um loop:

String[] seasons = new String {"Winter", "Spring", "Summer", "Autumn"}; 
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]); 
}

O programa exibirá o seguinte:

Winter 
Spring 
Summer 
Autumn

Arrays unidimensionais e multidimensionais em Java

Mas e se quisermos criar não um array de números, strings ou outros objetos, mas sim um array de arrays? Java permite que você faça isso. O tipo de array com o qual já estamos familiarizados ( int[] myArray = new int[8] ) é conhecido como array unidimensional. Mas uma matriz de matrizes é chamada de matriz bidimensional. É como uma tabela que tem um número de linha e um número de coluna. Ou, se você aprendeu o básico da álgebra linear, pode pensar nela como uma matriz. Por que precisamos de tais matrizes? Bem, para programar matrizes e tabelas, bem como outros objetos que tenham uma estrutura semelhante. Por exemplo, um tabuleiro de xadrez pode ser representado por uma matriz 8x8. Uma matriz multidimensional é declarada e criada da seguinte maneira:

Int[][] myTwoDimentionalArray = new int[8][8];

Este array tem exatamente 64 elementos: myTwoDimentionalArray[0][0] , myTwoDimentionalArray[0][1] , myTwoDimentionalArray[1][0] , myTwoDimentionalArray[1][1] e assim por diante até myTwoDimentionalArray[7][7] . Portanto, se o usarmos para representar um tabuleiro de xadrez, A1 corresponderá a myTwoDimentionalArray[0][0] e E2 corresponderá a myTwoDimentionalArray[4][1] . Mas até onde podemos levar isso? Em Java, você pode especificar um array de arrays... um array de arrays de arrays, e assim por diante. Claro, matrizes tridimensionais e de dimensão superior são usadas muito raramente. Dito isso, você poderia usar uma matriz tridimensional para programar um cubo de Rubik, por exemplo.

Métodos úteis para trabalhar com arrays

Java tem a classe java.util.Arrays para trabalhar com arrays. Em geral, as operações mais comuns executadas em arrays são inicialização (preenchimento com elementos), recuperação de um elemento (por índice), classificação e pesquisa. Pesquisar e classificar matrizes são tópicos para outro dia. Por um lado, é uma boa prática escrever você mesmo vários algoritmos de busca e classificação. Por outro lado, todos os melhores algoritmos já foram implementados e incluídos nas bibliotecas Java padrão, e você pode usá-los legalmente. Aqui estão três métodos úteis nesta classe.

Classificando uma matriz

O método void sort(int[] myArray, int fromIndex, int toIndex) classifica uma matriz inteira ou subarray em ordem crescente.

Procurando um elemento em um array

int binarySearch(int[] myArray, int fromIndex, int toIndex, int key) . Este método procura o elemento -chave em uma matriz ou subarray myArray classificada , de fromIndex para toIndex . Se o item for encontrado, ele retornará seu índice. Caso contrário, retorna (-fromIndex)-1 .

Convertendo um array em uma string

O método String toString(int[] myArray) converte uma matriz em uma string. Em Java, arrays não substituem toString() . Isso significa que, se você tentar exibir um array inteiro de uma só vez (System.out.println(myArray)) em vez de um elemento por vez, como no parágrafo intitulado " Exibir um array na tela ", obterá o nome da classe e o hash hexadecimal do array (definido por Object.toString() ). Se você é iniciante, pode não entender a explicação sobre o método toString . Inicialmente, você não precisa, mas usar esse método facilita a exibição de uma matriz. Java permite que você exiba facilmente uma matriz sem usar um loop. O exemplo abaixo demonstra isso.

Um exemplo usando sort, binarySearch e toString

Vamos criar um array de inteiros, exibi-lo usando toString , classificá-lo usando o método sort e, em seguida, encontrar algum número nele.

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; // Declare and initialize the array
        System.out.println(array); // Try to display our array without using the toString method — the result is a hexadecimal number
        System.out.println(Arrays.toString(array)); // Display the array correctly 
        Arrays.sort(array, 0, 4); // Sort the entire array from the zeroth to the fourth element
        System.out.println(Arrays.toString(array)); // Display the sorted array
        int key = Arrays.binarySearch(array, 5); // Look for the number 5 in the sorted array. 
        // The binarySearch method will return the index of the array element we are searching for
        System.out.println(key); // Display the index of the number we searched for 
System.out.println(Arrays.binarySearch(array, 0)); // Now try to find a number that isn't in the array, 
        // and immediately display the result

    }
}

Saída:

[I@1540e19d 
[1, 5, 4, 3, 7] 
[1, 3, 4, 5, 7] 
3 
-1

A primeira string é uma tentativa de exibir o array sem usar toString . A segunda é a matriz exibida usando toString . O terceiro é o array classificado. O quarto é o índice do número que procuramos (5) no array ordenado (lembre-se que contamos a partir de zero, então o índice do quarto elemento do array é 3). Na quinta string, vemos -1. Este é um índice de matriz inválido. Sinaliza que o número que procuramos (neste caso, 0) não está no array.

Matrizes em poucas palavras

• Características essenciais de um array: o tipo dos dados colocados nele, seu nome e seu comprimento.
  A última propriedade é determinada quando o array é criado (quando a memória é alocada para o array). As duas primeiras propriedades são determinadas quando a matriz é declarada.

• O tamanho da matriz (número de células) deve ser um int

• É impossível alterar o comprimento de um array depois que ele é criado.

• Um elemento de array pode ser acessado por seu índice.

• Elementos em arrays, como tudo em Java, são numerados começando do zero.

• Depois que uma matriz é criada, ela é preenchida com valores padrão.

• Arrays em Java não são iguais a arrays em C++. Eles são quase como ponteiros para arrays dinâmicos.

Materiais úteis sobre arrays

Quer saber mais sobre matrizes? Confira os artigos abaixo. Inclui muito material interessante e útil sobre este tópico.