Classe Arrays, parte 2

1.Arrays.fill()

Ao trabalhar com arrays, os programadores Java frequentemente precisam preencher o array com o mesmo valor. Você pode, é claro, escrever um loop e simplesmente atribuir algum valor a cada célula do array no loop:

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

Ou você pode simplesmente chamar o Arrays.fill()método, que faz exatamente a mesma coisa: ele preenche o array passado com o valor passado. Veja como fica:

Arrays.fill(name, value)

E o código do exemplo acima pode ser um pouco mais compacto e claro:

int[] x = new int[100];
Arrays.fill(x, 999);

Você também pode usar o Arrays.fill()método para preencher não todo o array, mas uma parte dele, com algum valor:

Arrays.fill(name, first, last, value)

Onde first e last são os índices da primeira e última células a serem preenchidas.

Exemplo:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

O Arrays.fill()método só funciona com arrays unidimensionais. Se você passar um array bidimensional para o método, ele será tratado como unidimensional, com todas as consequências decorrentes.

2.Arrays.copyOf()

Como você já sabe, não é possível redimensionar um array depois de criado.

Mas e se você realmente quiser?

Bem, se você realmente quiser, então você pode!

• Crie uma nova matriz do comprimento desejado
• Copie todos os elementos do primeiro array para ele.

Aliás, é exatamente isso que o Arrays.copyOf()método faz. É assim que a chamada se parece:

Type[] name2 = Arrays.copyOf(name, length);

Este método não altera o array existente , mas cria um novo array e copia os elementos do array antigo para ele.

Se os elementos não couberem (o comprimento for menor que o comprimento da matriz existente ), os valores extras serão ignorados.

Se o comprimento da nova matriz for maior que o comprimento da antiga, as células serão preenchidas com zeros.

Exemplo:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

"[1, 2, 3, 4, 5]"

"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.Arrays.copyOfRange()

E se você quiser obter um array de comprimento 5 de um array de comprimento 10, mas precisar que ele contenha os últimos 5 elementos em vez dos primeiros 5?

Nesse caso, outro método da Arraysclasse será útil — o método Arrays.copyOfRange(). Aqui está o que parece quando o chamamos:

Type[] name2 = Arrays.copyOfRange(name, first, last);

Este método também cria um novo array, mas o preenche com elementos de um lugar arbitrário no array original. Onde first e last são os índices do primeiro e último elementos que devem ser colocados no novo array.

Exemplo:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

"[16, 17, 18, 19, 20]"

"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

Ah, o deleite mais delicioso: triagem . As matrizes são classificadas com bastante frequência na programação. As três ações mais comuns ao trabalhar com arrays são:

• Classificando uma matriz
• Encontrando o elemento mínimo (ou máximo) de um array
• Determinar o índice de um elemento em uma matriz (encontrar um elemento em uma matriz)

É exatamente por isso que os criadores de Java incluíram o sort()método na Arraysclasse. É assim que a chamada se parece:

Arrays.sort(name);

Este método classifica o array passado em ordem crescente.

Exemplo:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);

String str = Arrays.toString(x);

"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

Excelente, certo? Você chamou um método e agora tem um array classificado. Lindo.

A propósito, você pode usar esse método para classificar não apenas a matriz inteira, mas apenas parte dela. É assim que a chamada se parece:

Arrays.sort(name, first, last);

Onde first e last são os índices da primeira e última células que a ordenação deve tocar.

Exemplo:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

Para classificar arrays, Java usa o algoritmo de classificação mais rápido — QuickSort . Sua complexidade computacional depende do tamanho da matriz e é calculada usando a fórmula N log(N).

A classificação de uma matriz de 1.000 elementos envolverá cerca de 3.000 comparações de elementos da matriz. Classificar uma matriz de um milhão de elementos envolverá cerca de 6 milhões de comparações.

5.Arrays.binarySearch()

Bem, e o último dos métodos mais interessantes da Arraysclasse é a capacidade de buscar um determinado valor em um array. Esta não é uma pesquisa comum - é a amada pesquisa binária . Tudo se resume a isso:

• Primeiro, a matriz é classificada.
• Em seguida, o elemento do meio da matriz é comparado com aquele que estamos procurando.
• Se o elemento for maior que o elemento do meio, a pesquisa continua na metade direita da matriz.
• Se o elemento que estamos procurando for menor que o elemento do meio, a pesquisa continua na metade esquerda da matriz.

Como o array está ordenado, é possível eliminar metade dele em uma única comparação. Então, na próxima etapa, jogamos fora outra metade e assim por diante.

Essa abordagem torna a pesquisa binária muito rápida. Em um array de um milhão (!) de elementos, ele consegue encontrar o índice do elemento desejado em apenas 20 comparações. A deficiência da abordagem é que a matriz deve primeiro ser classificada e a classificação também leva tempo.

É assim que a chamada se parece:

int index = Arrays.binarySearch(name, value);

Onde nameé o nome do array, que deve ser passado já ordenado (por exemplo, usando o Arrays.sort()método). E valueé o elemento que estamos procurando no array. O resultado retornado pelo método é o índice do elemento do array desejado .

Exemplos:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

Se a matriz contiver várias instâncias do elemento que está sendo procurado, o algoritmo simplesmente retornará o índice de uma delas (não há garantia de que será, digamos, a primeira ou vice-versa — a última delas elementos duplicados)."

Se o elemento não for encontrado na matriz, o índice será negativo.

6. Link para a documentação do Oracle na Arraysaula

Se você estiver super interessado, pode ler tudo sobre a Arraysclasse e todos os seus métodos na documentação oficial a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">no site da Oracle.

Por exemplo, você pode ler sobre os métodos Arrays.mismatch()e Arrays.compare(). Talvez você os ache úteis de alguma forma.

E não se confunda com o número de métodos. Cada método tem de 5 a 10 variantes, que diferem apenas em seus tipos de parâmetro.