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:
|
Estamos preenchendo as células x[3] , x[4] , x[5] e x[6] com o valor 999 . As células de um array são numeradas começando do zero! A str variável contém o valor:
|
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:
|
A str2 variável contém o valor:
A str3 variável contém o valor:
|
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 Arrays
classe 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:
|
A str2 variável contém o valor:
A str3 variável contém o valor:
|
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 Arrays
classe. É assim que a chamada se parece:
Arrays.sort(name);
Este método classifica o array passado em ordem crescente.
Exemplo:
|
A str variável contém o valor:
|
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:
|
A str variável contém o valor:
|
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 Arrays
classe é 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:
|
x é:
4 1 (índices 0 e 2 também são aceitáveis)8 -7 |
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 Arrays
aula
Se você estiver super interessado, pode ler tudo sobre a Arrays
classe 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.
GO TO FULL VERSION