Classe Arrays, parte 2

"Rishi, estou realmente ansioso para aprender sobre o restante dos métodos da classe Arrays.

"Tanto zelo pelo aprendizado não pode deixar de agradar seu antigo professor! Mas, se você realmente quiser descobrir tudo, um mago gentil chamado Google o ajudará dia e noite."

"Uh..."

"Brincadeirinha. Mais ou menos. Claro, vou explicar tudo melhor, mas se algo acontecer - lembre-se do bom mago. Vou começar a lição de hoje com o Arrays.fillmétodo

"Ao trabalhar com arrays, os programadores Java muitas vezes 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, em vez de tudo isso, você pode 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);

"Lindo!"

"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.

" De acordo com a boa (ou má) velha tradição de Java, lembre-se de que o último elemento não está incluído no intervalo.

Exemplo:

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

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


String str = Arrays.toString(x);

"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 daí decorrentes.

Arrays.copyOf()

"Amigo, por favor, diga-me como alterar o tamanho de um array depois de criado?"

"Umm... Essa é uma pergunta capciosa, certo? Não sou mais tão inexperiente. A resposta correta é que você não pode! Você não pode redimensionar um array depois que ele foi criado."

"Mas e se você realmente quiser?"

"Ainda é impossível!

"Na verdade, se você realmente quiser, então você pode! Com a ajuda de um truque de programação:

1. Primeiro, você cria uma nova matriz do comprimento desejado
2. Então você copia todos os elementos do primeiro array para ele.

"Essas são as duas coisas 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 a matriz existente , mas cria uma nova matriz e copia os elementos da matriz antiga para ela."

"E se o comprimento da nova matriz for menor que o comprimento da existente ?

"Ótima pergunta, amigo! Se os elementos não se encaixarem, os valores extras serão simplesmente ignorados."

“E se, ao contrário, houver células extras, quais são seus valores iniciais?

"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);

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 5 primeiros? Nesse caso, você precisa de outro método da classe. ArraysÉ Arrays.copyOfRange(). É assim que a chamada se parece:

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

"Este método também cria uma nova matriz, mas a preenche com elementos de um local arbitrário na matriz original. Onde primeiro e último são os índices do primeiro e último elementos que devem ser colocados na nova matriz. Você pode me dizer se o último elemento está incluído neste intervalo?"

"Ha! Como meu grande professor costumava dizer, ' de acordo com a boa (ou má) velha tradição de Java, lembre-se de que o último elemento não está incluído no intervalo '."

"Amigo, você está crescendo diante de nossos olhos.

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);

Arrays.sort()

"E, finalmente, deixei o método mais... mmm... agradável para o final: classificação . Os arrays são classificados com bastante frequência na programação. Aqui estão as 3 ações mais populares ao trabalhar com arrays:

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

"Algoritmos de classificação de bom desempenho, devo dizer, não são tão fáceis de escrever. Mais precisamente, esta é uma tarefa padrão e, como estudante, não fará mal algum praticar a escrita de algoritmos de classificação às vezes. Mas no trabalho, é melhor não perder seu tempo reinventando a roda. Os criadores de Java incluíram o sort()método na Arraysclasse. A chamada é assim:

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);

"Excelente! Chamei apenas um método e o array está organizado. Uma coisa linda!"

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

Arrays.sort(name, first, last);

"Onde primeiro e último são os índices da primeira e última células que a classificação deve tocar. E...

"Eu já sei o que você vai dizer! 'De acordo com a boa (ou má) velha tradição de Java, lembre-se de que o último elemento não está incluído no intervalo' .

Exemplo:

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

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

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

"Classificar uma matriz de 1.000 elementos envolverá cerca de 10.000 comparações de elementos da matriz. Classificar uma matriz de um milhão de elementos envolverá cerca de 20 milhões de comparações."

" Sem muitas comparações quando você considera o número de elementos!"

"É exatamente isso que estou dizendo. O algoritmo QuickSort é muito eficiente.

Arrays.binarySearch()

"Bem, e o último dos métodos mais interessantes da Arraysclasse é capaz de pesquisar um determinado valor em uma matriz. Esta não é uma pesquisa comum — é a adorada pesquisa binária . Tudo se resume a isto:

• 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, descartamos outra metade e assim por diante."

"Fantástico! Vamos direto para o gol muito rapidamente!"

"Exatamente. Em uma matriz de um milhão (!) de elementos, o algoritmo de busca binária pode encontrar o índice do elemento desejado em apenas 20 comparações. A deficiência do algoritmo é 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 nameestá o nome do array, que deve ser passado já ordenado (por exemplo, usando o Arrays.sort()método). E valueé o elemento que estamos buscando 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);

"E se o elemento desejado aparecer várias vezes no array ?"

"Essa é uma pergunta válida, amigo. Nesse caso, o algoritmo retornará o índice de um deles (não há garantia de que será, digamos, o primeiro, ou vice-versa - o último desses elementos duplicados) ."

"E se a matriz não contiver o elemento desejado?"

"Nesse caso, o algoritmo retornará um índice negativo .

Documentação

"Tudo está claro, Rishi! Isso foi muito interessante."

"Se você realmente achou isso muito interessante, então, à vontade, folheie a documentação oficial da Arraysclasse e seus métodos no site da Oracle .

"Você pode examinar mais de perto, por exemplo, os métodos Arrays.mismatch()e Arrays.compare(). Você provavelmente será capaz de fazer bom uso deles.

"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."