Arrays de classes auxiliares

1. Arraysaula

Como observamos anteriormente, os arrays são muito úteis e frequentemente usados ​​na programação.

Os criadores de Java perceberam rapidamente que os programadores de Java geralmente escrevem o mesmo código ao trabalhar com arrays. Por exemplo, copiar parte de um array para outro array, codificar para preencher cada célula de um array com o mesmo valor, exibir o conteúdo de um array em um formato conveniente, etc.

É por isso que eles criaram a Arraysclasse especial (seu nome completo é java.util.Arrays), colocando nela as ações relacionadas a arrays mais populares.

Ele tem muitos métodos para cada ocasião, mas primeiro vamos considerar apenas 10 deles — os mais simples e os mais usados.

2.Arrays.toString()

O primeiro método que veremos é chamado Arrays.toString(). Mas primeiro, uma rápida explicação.

Cada array em Java possui um toString()método, que retorna uma 'representação textual do array'. Você pode obter uma representação textual de uma matriz usando a seguinte instrução:

String str = name.toString();

Onde nameé o nome da variável do array e stré o nome da variável que armazenará a representação de string do array.

Mas se você tentar imprimir a matriz na tela usando o método, provavelmente verá algo assim:System.out.println(name)

I@37afeb11

A primeira letra Isignifica que é um intarray, e os símbolos depois @são o endereço do array na memória. Por um lado, essa é justamente a informação armazenada na variável array, mas por outro, esperávamos algo diferente, certo?

Queríamos ver os valores no array! E é exatamente por isso que eles criaram o Arrays.toString()método — para exibir os valores de um array. Chamamos assim:

String str = Arrays.toString(name);

Exemplos:

int[] array = {1, 2, 3};
String str = Arrays.toString(array);

"[1, 2, 3]"

int[] array = {};
String str = Arrays.toString(array);

"[]"

String[] array = {"Hi", "How's", "life?"};
String str = Arrays.toString(array);

"[Hi, How's, life?]"

3.Arrays.deepToString()

Mas se você tentar converter um array bidimensional em um using the Arrays.toString()método de string (para exibi-lo), verá algo familiar:

[I@37afeb11, I@37afeb21, I@37afeb31]

Isso ocorre porque as células de uma matriz bidimensional armazenam referências a matrizes unidimensionais. E como os arrays unidimensionais são convertidos em uma string? Exatamente como você vê acima.

O que pode ser feito? Como exibimos corretamente um array bidimensional?

Para esse fim, a Arraysclasse possui outro método especial — deepToString(). Chamando fica assim:

String str = Arrays.deepToString(name);

Este método pode passar arrays bidimensionais, unidimensionais, tridimensionais ou, em geral, qualquer dimensão, e sempre exibirá os elementos do array.
Nota: o Arrays.deepToString()método não funciona com arrays unidimensionais de primitivas (por exemplo, int[]).

Exemplos:

Integer[] array = {1, 2, 3};
String str = Arrays.deepToString(array);

"[1, 2, 3]"

int[][] array = { {1, 1}, {2, 2}, {3, 3} };
String str = Arrays.deepToString(array);

"[[1, 1], [2, 2], [3, 3]]"

int[][][] array = { {{1, 2, 3}, {1}}, {{}} };
String str = Arrays.deepToString(array);

"[[[1, 2, 3], [1]], [[]]]"

4.Arrays.equals()

Descobrimos como exibir arrays na tela, mas e comparar arrays?

Para comparar strings, temos métodos equalse equalsIgnoreCase, mas quais métodos os arrays possuem?

A boa notícia é que os arrays têm um equalsmétodo. A má notícia é que ele não compara o conteúdo dos arrays. O equalsmétodo de arrays faz a mesma coisa que o ==operador — ele compara referências. Exemplos:

Exemplos:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
boolean b = x1 == x2;

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

O que pode ser feito? Como comparamos arrays com base em seu conteúdo?

E novamente Arraysvem em nosso socorro, ou mais especificamente, seu Arrays.equals()método. É assim que o chamamos:

Arrays.equals(name1, name2)

O método retorna truese as matrizes tiverem o mesmo comprimento e seus elementos forem iguais. Caso contrário, ele retorna false.

Exemplos:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
Arrays.equals(x1, x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3, 4};
Arrays.equals(x1, x2);

5.Arrays.deepEquals()

E, como você provavelmente já adivinhou, o Arrays.equalsmétodo não funcionará corretamente para arrays bidimensionais: ele trata arrays bidimensionais como um array unidimensional cujos elementos são endereços de arrays unidimensionais.

Assim, para comparar corretamente arrays multidimensionais ( n = 1, 2, 3,...), eles criaram o Arrays.deepEquals()método. Chamando fica assim:

Arrays.deepEquals(name1, name2)

O método retornatruese as matrizes tiverem comprimento igual e seus elementos forem iguais. Caso contrário, ele retornafalse. Se os elementos dentro da matriz também forem matrizes, o Arrays.deepEquals()método será usado para compará-los e assim por diante.

Exemplos:

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
x1.equals(x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.equals(x1, x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.deepEquals(x1, x2);