java array class tutorial java
Este tutorial cobre a classe Array em Java e os métodos da classe java.util.arrays, juntamente com a descrição detalhada e exemplos de métodos da classe Array:
A classe ‘Arrays’ é membro do pacote ‘java.util’. Isso faz parte da estrutura do Java Collections e fornece métodos para criar, acessar e manipular arrays Java dinamicamente.
Todos os métodos fornecidos pela classe Arrays são de natureza estática e são métodos da classe ‘Object’. Como os métodos são estáticos, eles podem ser acessados usando o próprio nome da classe.
=> Verifique TODOS os tutoriais Java aqui.
O que você aprenderá:
Classe Array Java
A classe Arrays foi introduzida no Java 1.2 e os métodos que ela contém são usados principalmente para manipulação do array, incluindo pesquisa, classificação, etc. A classe arrays fornece métodos sobrecarregados para quase todos os tipos de dados.
A hierarquia de classes para a classe Arrays é mostrada abaixo:

A classe Arrays estende-se da classe Object e seus métodos são métodos da classe Object.
A sintaxe geral para acessar qualquer método da classe Arrays é:
Arrays.;Na próxima seção, listaremos os vários métodos fornecidos pela classe Arrays.
Métodos Java Arrays
As tabelas a seguir fornecem uma introdução aos vários métodos fornecidos pela classe Arrays. Listamos aqui os principais métodos. Observe que a maioria dos métodos são sobrecarregados para fornecer suporte para todos os tipos primitivos.
Listaremos o protótipo e a descrição de cada uma das funções. Em seguida, na seção a seguir, descreveremos alguns dos métodos importantes, fornecendo exemplos de programação.
| Nome do Método | Protótipo | Descrição |
|---|---|---|
| static int binarySearch (double () a, int fromIndex, int toIndex, chave dupla) | Pesquisa a chave no intervalo especificado em uma matriz dupla | |
| asList | lista estática< T> asList (Object () a) | Retorna uma lista (tamanho fixo) da matriz especificada |
| binarySearch Este método usa o algoritmo de pesquisa binária. Na próxima coluna, são mostradas várias sobrecargas do método binarySearch. | static int binarySearch (byte () a, chave de byte) | Pesquisa uma chave em uma matriz de bytes |
| static int binarySearch (byte () a, int fromIndex, int toIndex, chave de byte) | Pesquisa a chave no intervalo especificado em uma matriz de bytes | |
| static int binarySearch (char () a, chave char) | Pesquisa uma chave em uma matriz de caracteres | |
| static int binarySearch (char () a, int fromIndex, int toIndex, chave char) | Pesquisa a chave no intervalo especificado em uma matriz de caracteres | |
| static int binarySearch (double () a, double key) | Pesquisa uma chave em uma matriz dupla | |
| static int binarySearch (float () a, chave float) | Pesquisa uma chave em uma série de flutuadores | |
| static int binarySearch (float () a, int fromIndex, int toIndex, chave float) | Pesquisa a chave no intervalo especificado em uma matriz de floats | |
| static int binarySearch (int () a, chave int) | Pesquisa uma chave em um array int | |
| static int binarySearch (int () a, int fromIndex, int toIndex, chave int) | Pesquisa a chave no intervalo especificado em uma matriz int | |
| static int binarySearch (long () a, chave longa) | Pesquisa uma chave em longa matriz | |
| static int binarySearch (long () a, int fromIndex, int toIndex, chave longa) | Pesquisa a chave no intervalo especificado em longa matriz | |
| static int binarySearch (Object () a, Object key) | Pesquisa uma chave em um array de objetos | |
| static int binarySearch (Object () a, int fromIndex, int toIndex, chave do objeto) | Pesquisa a chave no intervalo especificado na matriz de objetos | |
| static int binarySearch (short () a, chave curta) | Procura uma chave em uma variedade de shorts | |
| static int binarySearch (short () a, int fromIndex, int toIndex, chave curta) | Pesquisa a chave no intervalo especificado em uma série de shorts | |
| static int binarySearch (T () a, tecla T, Comparador c) | Pesquisa uma chave em uma série de objetos especificados | |
| static int binarySearch (T () a, int fromIndex, int toIndex, chave T, Comparador c) | Pesquisa a chave no intervalo especificado na matriz de objetos |
| Nome do Método | Protótipo | Descrição |
|---|---|---|
| static long () copyOf (long () original, int newLength) | Copia a matriz especificada. Trunca ou acrescenta zeros se necessário | |
| cópia de O método é usado para copiar a matriz com o comprimento especificado. A próxima coluna lista as sobrecargas deste método | static boolean () copyOf (boolean () original, int newLength) | Copia a matriz especificada. Trunca ou acrescenta valores ‘false’ se necessário |
| byte estático () copyOf (byte () original, int newLength) | Copia a matriz especificada. Trunca ou acrescenta zeros se necessário | |
| static char () copyOf (char () original, int newLength) | Copia a matriz especificada. Trunca ou acrescenta nulo se necessário | |
| static double () copyOf (double () original, int newLength) | Copia a matriz especificada. Trunca ou acrescenta zeros se necessário | |
| static float () copyOf (float () original, int newLength) | Copia a matriz especificada. Trunca ou acrescenta zeros se necessário | |
| static int () copyOf (int () original, int newLength) | Copia a matriz especificada. Trunca ou acrescenta zeros se necessário | |
| static short () copyOf (short () original, int newLength) | Copia a matriz especificada. Trunca ou acrescenta zeros se necessário | |
| static T () copyOf (T () original, int newLength) | Copia a matriz especificada. Trunca ou acrescenta nulos, se necessário | |
| static T () copyOf (U () original, int newLength, ClassnewType) | Copia a matriz especificada. Trunca ou acrescenta nulos, se necessário | |
| copyOfRange Este método é usado para copiar um intervalo especificado na matriz. As sobrecargas para este método são fornecidas na próxima coluna | static boolean () copyOfRange (boolean () original, int de, int para) | Copia a matriz com o intervalo especificado em uma nova matriz |
| byte estático () copyOfRange (byte () original, int de, int para) | Copia a matriz com o intervalo especificado em uma nova matriz | |
| static char () copyOfRange (char () original, int de, int para) | Copia a matriz com o intervalo especificado em uma nova matriz | |
| static double () copyOfRange (double () original, int de, int para) | Copia a matriz com o intervalo especificado em uma nova matriz | |
| static float () copyOfRange (float () original, int de, int para) | Copia a matriz com o intervalo especificado em uma nova matriz | |
| static int () copyOfRange (int () original, int de, int para) | Copia a matriz com o intervalo especificado em uma nova matriz | |
| static long () copyOfRange (long () original, int de, int para) | Copia a matriz com o intervalo especificado em uma nova matriz | |
| static short () copyOfRange (short () original, int de, int para) | Copia a matriz com o intervalo especificado em uma nova matriz | |
| static T () copyOfRange (T () original, int de, int para) | Copia a matriz com o intervalo especificado em uma nova matriz | |
| static T () copyOfRange (U () original, int de, int para, ClassnewType) | Copia a matriz com o intervalo especificado em uma nova matriz |
| Nome do Método | Protótipo | Descrição |
|---|---|---|
| iguais booleanos estáticos (double () a, double () a2) | Retorna verdadeiro se as duas matrizes duplas especificadas forem iguais. | |
| deepEquals | static boolean deepEquals (Object () a1, Object () a2) | Verifica se dois arrays especificados são profundamente iguais |
| deepHashCode | static intdeepHashCode (Object () a) | Retorna um código hash da matriz especificada |
| deepToString | static StringdeepToString (Object () a) | Retorna o 'conteúdo profundo' da matriz especificada em uma string |
| É igual a Verifica se dois arrays especificados são iguais | estáticos booleanos iguais (boolean () a, boolean () a2) | Retorna verdadeiro se os dois booleanarrays especificados forem iguais. |
| iguais booleanos estáticos (byte () a, byte () a2) | Retorna verdadeiro se as duas matrizes de bytes especificadas forem iguais | |
| booleanos estáticos iguais (char () a, char () a2) | Retorna verdadeiro se as duas matrizes de caracteres especificadas forem iguais. | |
| estáticos booleanos iguais (float () a, float () a2) | Retorna verdadeiro se as duas matrizes de float especificadas forem iguais. | |
| booleanos estáticos iguais (int () a, int () a2) | Retorna verdadeiro se as duas matrizes int especificadas forem iguais. | |
| booleanos estáticos iguais (long () a, long () a2) | Retorna verdadeiro se as duas matrizes longas especificadas forem iguais. | |
| estáticos booleanos iguais (Object () a, Object () a2) | Retorna verdadeiro se as duas matrizes de objetos especificadas forem iguais. | |
| booleanos estáticos iguais (short () a, short () a2) | Retorna verdadeiro se as duas matrizes curtas especificadas forem iguais. |
| Nome do Método | Protótipo | Descrição |
|---|---|---|
| preenchimento de vazio estático (double () a, double val) | Preenche a matriz dupla com o valor duplo especificado | |
| preencher Preenche a matriz (todos os elementos) com o valor especificado. A próxima coluna fornece as sobrecargas para esta função | preenchimento vazio estático (boolean () a, boolean val) | Preenche a matriz booleana com um valor booleano especificado |
| preenchimento vazio estático (boolean () a, int fromIndex, int toIndex, boolean val) | Atribui um valor booleano ao intervalo especificado na matriz booleana. | |
| preenchimento de vazio estático (byte () a, byte val) | Preenche a matriz de bytes com um valor de byte especificado | |
| preenchimento vazio estático (byte () a, int fromIndex, int toIndex, byte val) | Preenche a matriz de bytes com o valor de byte especificado no intervalo fornecido | |
| preenchimento de vazio estático (char () a, char val) | Preenche a matriz de char com o valor de char especificado | |
| preenchimento vazio estático (char () a, int fromIndex, int toIndex, char val) | Preenche o intervalo da matriz de char com o valor de char especificado | |
| preenchimento de vazio estático (double () a, int fromIndex, int toIndex, double val) | Atribui um valor duplo ao intervalo especificado na matriz dupla. | |
| preenchimento de vazio estático (float () a, float val) | Atribui um valor flutuante ao intervalo especificado na matriz flutuante. | |
| preenchimento vazio estático (float () a, int fromIndex, int toIndex, float val) | Atribui um valor flutuante ao intervalo especificado na matriz flutuante. | |
| preenchimento de vazio estático (int () a, int val) | Atribui valor int ao array int. | |
| preenchimento vazio estático (int () a, int fromIndex, int toIndex, int val) | Atribui o valor int ao intervalo especificado na matriz int. | |
| preenchimento vazio estático (long () a, int fromIndex, int toIndex, long val) | Atribui um valor longo ao intervalo especificado na matriz longa. | |
| preenchimento de vazio estático (long () a, long val) | Atribui um valor longo à matriz longa. | |
| preenchimento vazio estático (Object () a, int fromIndex, int toIndex, Object val) | Atribui referência de objeto ao intervalo especificado na matriz de objeto. | |
| preenchimento de vazio estático (Object () a, Object val) | Atribui referência de objeto ao objectarray especificado | |
| preenchimento vazio estático (short () a, int fromIndex, int toIndex, short val) | Atribui um valor curto ao intervalo especificado na matriz curta. | |
| preenchimento de vazio estático (short () a, short val) | Atribui um valor curto à matriz curta especificada. |
| Nome do Método | Protótipo | Descrição |
|---|---|---|
| classificação de vazio estático (float () a) | Classifica a matriz flutuante em ordem numérica crescente. | |
| Organizar Classifica a matriz passada como parâmetro para o método. Sobrecargas são fornecidas na próxima coluna. | classificação vazia estática (byte () a) | Classifica a matriz de bytes numericamente |
| classificação vazia estática (byte () a, int fromIndex, int toIndex) | Classifica o intervalo de elementos da matriz | |
| classificação vazia estática (char () a) | Classifica a matriz de caracteres em ordem numérica crescente. | |
| static void sort (char () a, int fromIndex, int toIndex) | Classifica o intervalo de elementos na matriz em ordem crescente. | |
| classificação de vazio estático (double () a) | Classifica a matriz dupla em ordem numérica crescente. | |
| classificação vazia estática (double () a, int fromIndex, int toIndex) | Classifica o intervalo de elementos da matriz em ordem crescente. | |
| static void sort (float () a, int fromIndex, int toIndex) | Classifica o intervalo de elementos da matriz em ordem crescente. | |
| classificação de vazio estático (int () a) | Classifica a matriz int em ordem numérica crescente. | |
| static void sort (int () a, int fromIndex, int toIndex) | Classifica a gama de elementos da matriz em ordem crescente. | |
| classificação de vazio estático (long () a) | Classifica a longa matriz em ordem numérica crescente. | |
| classificação vazia estática (long () a, int fromIndex, int toIndex) | Classifica o intervalo de elementos da matriz em ordem crescente | |
| classificação de vazio estático (Object () a) | Classifica a matriz de objetos em ordem crescente. A classificação é feita de acordo com a ordem natural de seus elementos | |
| static void sort (Object () a, int fromIndex, int toIndex) | Classifica o intervalo especificado de uma matriz de objetos em ordem crescente. A classificação é feita de acordo com a ordem natural de seus elementos. | |
| classificação de vazio estático (curto () a) | Classifica a matriz do tipo curto em ordem numérica crescente. | |
| static void sort (short () a, int fromIndex, int toIndex) | Classifica o intervalo de elementos da matriz em ordem crescente. | |
| classificação de vazio estático (T () a, Comparador c) | Classifica a matriz especificada de objetos. A ordem de classificação é induzida de acordo com o comparador especificado. | |
| classificação de vazio estático (T () a, int fromIndex, int toIndex, Comparator c) | Classifica o intervalo de elementos de uma matriz de objetos na ordem especificada pelo comparador. |
| Nome do Método | Protótipo | Descrição |
|---|---|---|
| String estática toString (long () a) | Retorna uma representação de string de uma longa matriz | |
| para sequenciar Este método retorna a representação de string de um determinado array. Diferentes sobrecargas deste método são fornecidas na próxima coluna | static String toString (boolean () a) | Retorna uma representação de string de uma matriz booleana |
| String estática toString (byte () a) | Retorna uma representação de string de uma matriz de bytes | |
| String estática toString (char () a) | Retorna uma representação de string de uma matriz de caracteres | |
| String estática toString (double () a) | Retorna uma representação de string de uma matriz dupla | |
| String toString estática (float () a) | Retorna uma representação de string de uma matriz flutuante | |
| String estática toString (int () a) | Retorna uma representação de string de uma matriz int | |
| String toString estática (Object () a) | Retorna uma representação de string de uma matriz de objeto | |
| String toString estática (short () a) | Retorna uma representação de string de um array curto |
| Nome do Método | Protótipo | Descrição |
|---|---|---|
| static int hashCode (long () a) | Retorna o código hash do conteúdo de uma longa matriz | |
| hashCode Este método retorna o hashCode do conteúdo da matriz especificada Os métodos sobrecarregados são fornecidos na próxima coluna. | static int hashCode (boolean () a) | Retorna o código hash do conteúdo da matriz booleana |
| static int hashCode (byte () a) | Retorna o código hash do conteúdo da matriz de bytes | |
| static int hashCode (char () a) | Retorna o código hash do conteúdo da matriz de caracteres | |
| static int hashCode (double () a) | Retorna o código hash do conteúdo de uma matriz dupla | |
| static int hashCode (float () a) | Retorna o código hash do conteúdo de uma matriz flutuante | |
| static int hashCode (int () a) | Retorna o código hash do conteúdo de uma matriz int. | |
| static int hashCode (Object () a) | Retorna o código hash do conteúdo da matriz de objetos | |
| static int hashCode (short () a) | Retorna o código hash do conteúdo do array curto |
As tabelas acima mostram todos os métodos fornecidos pela classe Arrays. A maioria deles está sobrecarregada para vários tipos primitivos.
Vamos discutir alguns desses métodos em detalhes.
# 1) asList
Protótipo: Lista estática asList (Object () a)
Parâmetros: a - array de objetos dos quais a lista será apoiada.
Valor de retorno: Lista => lista de tamanho fixo da matriz especificada
Descrição: Retorna uma lista serializável de tamanho fixo apoiada por uma matriz fornecida como argumento.
Exemplo:
import java.util.Arrays; import java.util.List; public class Main { public static void main(String() args) { String() months = {'January', 'February', 'March', 'April', 'May'}; // converted string array to a List using asList System.out.println('The string array converted to list:'); List month_list = Arrays.asList(months); System.out.println(month_list); } } Resultado:

O programa acima demonstra o uso do método ‘asList’ da classe Arrays. Aqui, declaramos um array de strings e o passamos para o método asList para obter uma lista.
# 2) binarySearch
Protótipo: static int binarySearch (int () a, chave int)
Parâmetros:
a => array em que a chave deve ser pesquisada
Chave => valor do elemento a ser pesquisado
Valor de retorno: int => posição (índice) em que a chave é encontrada, senão retorna (- (o “ponto de inserção”) - 1).
Descrição: Pesquisa a chave especificada na matriz fornecida usando um algoritmo de pesquisa binária. A matriz precisa ser classificada para que a pesquisa binária funcione. Se a matriz não for classificada, os resultados serão indefinidos. Além disso, se houver vários locais na matriz para o mesmo valor-chave, a posição retornada não é garantida.
Exemplo:
import java.util.Arrays; import java.util.List; public class Main { public static void main(String() args) { // define the Array int numArr() = { 23,43,26,65,35,16,74,27,98 }; //sort the array first Arrays.sort(numArr); System.out.println('Input array:' + Arrays.toString(numArr)); int key = 35; //call binarySearch function to search a given key System.out.println('Key ' + key + ' found at index = ' + Arrays .binarySearch(numArr, key)); } } Resultado:

No programa acima, primeiro classificamos a matriz de entrada, pois para binarySearch a matriz deve ser classificada. Em seguida, a matriz e a chave a serem pesquisadas são passadas para o método ‘binarySearch’. O índice no qual a chave é encontrada é exibido na saída.
Protótipo: static int binarySearch (int () a, int fromIndex, int toIndex, chave int)
Parâmetros:
a => array a ser pesquisado
fromIndex => índice inicial do intervalo no qual a chave deve ser pesquisada
toIndex => o índice do último elemento no intervalo
chave => chave a ser pesquisada
Valor de retorno: índice do elemento-chave é encontrado no intervalo especificado. Caso contrário, retorna (- (o “ponto de inserção”) - 1).
Descrição: Essa sobrecarga de binarySearch procura por um valor de chave no intervalo especificado da matriz e retorna a posição do índice do elemento chave, se encontrado. A matriz e, portanto, o intervalo precisam ser classificados para que binarySearch funcione. Se não estiver classificado, os resultados serão indefinidos.
Exemplo:
import java.util.Arrays; import java.util.List; public class Main { public static void main(String() args) { int numArr() = { 23,43,26,65,35,16,74,27,98 }; // define the Array Arrays.sort(numArr); //sort the array first System.out.println('Input array:' + Arrays.toString(numArr)); int key = 35; //call binarySearch function to search a given key System.out.println('Key ' + key + ' found at index = ' + Arrays .binarySearch(numArr,3,7, key)); } } Resultado:

o que é nome de usuário e senha para roteador
O programa acima é igual ao anterior, com a diferença de que, na chamada do método binarySearch, especificamos um intervalo do array em que a pesquisa deve ser realizada.
# 3) copyOf
Protótipo: static int () copyOf (int () original, int newLength)
Parâmetros:
original => array a ser copiado
newLength => comprimento da matriz copiada
Valor de retorno: Uma nova matriz copiada do original e preenchida ou truncada com zeros dependendo do comprimento especificado.
Descrição: Copia o original da matriz em uma nova matriz e a preenche ou trunca com zeros, dependendo do comprimento especificado.
Exemplo:
import java.util.Arrays; public class Main { public static void main(String() args) { // define the Array String strArr() = {'Java', 'Python', 'Perl', 'C', 'Ruby'}; // print the original array System.out.println('Original String Array: ' + Arrays.toString(strArr)); //copy the array into new array using copyOf and print it System.out.println('Copied Array: ' + Arrays.toString( Arrays.copyOf(strArr, 5))); } } Resultado:

O programa acima demonstra o uso do método ‘copyOf’ da classe Arrays que copia o array fornecido em um novo. O programa acima copia o array de strings original em um novo array.
# 4) copyOfRange
Protótipo: static int () copyOfRange (int () original, int de, int para)
Parâmetros:
original => matriz da qual os valores no intervalo devem ser copiados
De => primeiro índice do intervalo
Para => último índice do intervalo
Valor de retorno: Nova matriz com valores do intervalo especificado com zeros truncados ou preenchidos para obter o comprimento desejado.
Descrição: Copia o intervalo especificado de uma determinada matriz em uma nova matriz. O índice inicial da matriz deve ser inclusivo entre 0 e original.length. O índice final pode ser exclusivo.
Exemplo:
import java.util.Arrays; public class Main { public static void main(String() args) { // define the Array String strArr() = {'Java', 'Python', 'Perl', 'C', 'Ruby'}; // print the original array System.out.println('Original String Array: ' + Arrays.toString(strArr)); //copy the array into new array using copyOfRange and print it System.out.println('Copied Range of Array: ' + Arrays.toString( Arrays.copyOfRange(strArr,1,3))); } } Resultado:

Modificamos o programa anterior para usar o método ‘copyOfRange’ que copia um intervalo específico da matriz e forma uma nova matriz. No programa acima, especificamos o intervalo como 1, 3. Portanto, a saída mostra uma nova matriz de 2 elementos.
# 5) É igual
Protótipo: booleanos estáticos iguais (int () a, int () a2)
Parâmetros:
para => primeira matriz a ser testada para igualdade
A2 => segunda matriz a ser testada quanto à igualdade
Valor de retorno: Retorna verdadeiro se ambas as matrizes forem iguais.
Descrição: Este método verifica se os dois arrays são iguais e retorna os resultados. As duas matrizes são consideradas iguais se ambas as matrizes tiverem um número igual de elementos e os elementos correspondentes em ambas as matrizes forem iguais.
Exemplo:
import java.util.Arrays; public class Main { public static void main(String() args) { // define two arrays, array_One and array_Two int() array_One = { 1, 3, 5, 7 }; int() array_Two = { 1, 3, 5, 7 }; //print the arrays System.out.println('array_One = ' + Arrays.toString(array_One)); System.out.println('array_Two = ' + Arrays.toString(array_Two)); //use equals method to check for equality of arrays booleanarray_equal = Arrays.equals(array_One, array_Two); //print the results if (array_equal) { System.out.println('equals method returns ' + array_equal + ', hence arrays array_One and array_Two are equal
'); }else { System.out.println('equals method returns ' + array_equal + ', hence arrays array_One and array_Two are not equal
'); } // define two more arrays, firstArray&secondArray int() firstArray = { 2, 4, 6, 8 }; int() secondArray = { 1, 3, 5, 7}; //display these arrays System.out.println('firstArray = ' + Arrays.toString(firstArray)); System.out.println('secondArray = ' + Arrays.toString(secondArray)); //use equals method to check equality of arrays boolean test_array = Arrays.equals(firstArray, secondArray); //print the results if (test_array) { System.out.println('equals method returns ' + test_array + ', hence arrays firstArray and secondArray are equal
'); }else { System.out.println('equals method returns ' + test_array + ', hence arrays firstArray and secondArray are not equal
'); } } } Resultado:

O programa acima demonstra o método 'igual'. Aqui, usamos dois conjuntos de matrizes e chamamos de 'igual' duas vezes. Na primeira chamada para equals, as duas matrizes são iguais e, portanto, o método retorna true. Na segunda chamada para equals, as duas matrizes são diferentes e o método retorna false.
# 6) Preencher
Protótipo: preenchimento de vazio estático (int () a, int val)
Parâmetros:
a => array a ser preenchido
val => valor a ser preenchido em todos os lugares na matriz
Valor de retorno: Nenhum
Descrição: Preenche a matriz com o valor especificado.
Exemplo:
import java.util.Arrays; public class Main { public static void main(String() args) { // define the array int() intArray = { 1, 3, 5, 7 }; //print original array System.out.println('The original array: ' + Arrays.toString(intArray)); //call fill method to fill the array with all zeros Arrays.fill(intArray, 0); //print altered array System.out.println('Array after call to fill:' + Arrays.toString(intArray)); } } Resultado:
melhor monitor de temperatura de CPU e GPU

O programa acima mostra a versão básica do método de preenchimento. Aqui, apenas preenchemos o array inteiro com outro valor. Neste caso, preenchemos o array com todos os zeros.
Protótipo: preenchimento vazio estático (int () a, int fromIndex, int toIndex, int val)
Parâmetros:
a => array cujo intervalo deve ser preenchido
fromIndex => índice inicial do intervalo
toIndex => índice final do intervalo
val => valor com o qual os elementos do intervalo devem ser preenchidos
Valor de retorno: Nenhum
Descrição: Preenche o intervalo especificado de fromIndex a toIndex na matriz ‘a’ com o valor especificado. Se fromIndex = toIndex, o intervalo a ser preenchido está vazio.
Exemplo:
import java.util.Arrays; public class Main { public static void main(String() args) { // define the array int() intArray = { 1, 3, 5, 7, 9, 11, 13, 15,17}; //print original array System.out.println('The original array: ' + Arrays.toString(intArray)); //call fill method to fill the range (2,6) in the array with zeros Arrays.fill(intArray, 2, 6, 0); //print altered array System.out.println('Array after call to fill the range(2,6):' + Arrays.toString(intArray)); } }Resultado:

Esta é outra versão do método de preenchimento, em que especificamos o intervalo particular na matriz que deve ser preenchida com um valor diferente. No programa acima, especificamos o intervalo (2, 6) a ser preenchido com zeros. Os outros elementos permanecem os mesmos, conforme mostrado na saída.
# 7) Classificar
Protótipo: classificação de vazio estático (int () a)
Parâmetros: a => array a ser classificado
Valor de retorno: Nenhum
Descrição: Este método classifica a matriz em ordem crescente.
Exemplo:
import java.util.Arrays; public class Main { public static void main(String() args) { // define the array int() intArray = {10,4,25,63,21,51,73,24,87,18}; //print original array System.out.println('The original array: ' + Arrays.toString(intArray)); //call sort method to sort the given array in ascending order Arrays.sort(intArray); //print altered array System.out.println('Sorted array:' + Arrays.toString(intArray)); } }Resultado:

O programa acima classifica um array de inteiros usando o método sort da classe Arrays e imprime o array ordenado.
Protótipo: static void sort (int () a, int fromIndex, int toIndex)
Parâmetros:
melhores sites para assistir anime grátis
a => array a partir do qual um intervalo deve ser classificado
fromIndex => índice inicial para o intervalo
toIndex => índice final para o intervalo
Valor de retorno: Nenhum
Descrição: Classifica o intervalo especificado de fromIndex a toIndex em ordem crescente. Se fromIndex = toIndex, o intervalo a ser classificado está vazio.
Exemplo:
import java.util.Arrays; public class Main { public static void main(String() args) { // define the array int() intArray = {10,4,25,63,21,51,73,24,87,18}; //print original array System.out.println('The original array: ' + Arrays.toString(intArray)); //call sort method to sort the given range in the array in ascending order Arrays.sort(intArray, 2, 7); //print altered array System.out.println('Sorted range(2,7) in the array:' + Arrays.toString(intArray)); } }Resultado:

O programa acima demonstra a variação do método de classificação. Nesse caso, podemos especificar um intervalo no qual a matriz deve ser classificada. Os elementos fora deste intervalo não são classificados. No programa acima, o intervalo (2,7) na matriz fornecida é especificado para ser classificado no método de classificação.
Portanto, na saída, podemos ver que apenas os elementos neste intervalo são classificados em ordem crescente.
# 8) toString
Protótipo: String estática toString (int () a)
Parâmetros: um => array cuja representação de string é necessária
Valor de retorno: string => representação de string da matriz
Descrição: Converte a matriz fornecida em sua representação de string.
Exemplo:
import java.util.*; public class Main { public static void main(String() args) { //declare arrays of type int and double int() intArray = {10,20,30,40,50}; double() dblArray = {1.0,2.0,3.0,4.0,5.0}; System.out.println('String representation of int Array: '); //print string representation of int array using toString System.out.println(Arrays.toString(intArray)); System.out.println('
String representation of double Array: '); //print string representation of double array using toString System.out.println(Arrays.toString(dblArray)); } }Resultado:

No exemplo acima, usamos o método toString que converte os arrays em uma representação de string. Portanto, para demonstrar esse método, usamos duas matrizes, cada uma do tipo int e double. Em seguida, usando o método toString, cada um desse array é convertido em sua representação de string correspondente mostrada na saída.
# 9) hashCode
Protótipo: static int hashCode (int () a)
Parâmetros: a => array cujo código hash deve ser calculado.
Valor de retorno: int => hashcode calculado
Descrição: O método retorna o código hash de uma determinada matriz. O hashcode de um Java O objeto é na verdade um número de 32 bits (int assinado). Usando hashcode, você pode gerenciar um objeto usando uma estrutura baseada em hash.
O Hashcode é alocado pela JVM para um objeto e geralmente é único, a menos que os dois objetos sejam iguais, caso em que ambos os objetos terão o mesmo hashcode.
Exemplo:
import java.util.*; public class Main { public static void main(String() args) { //declare arrays of type int int() intArray = {10,20,30,40,50}; //print the input array System.out.println('The input Array: ' + Arrays.toString(intArray)); //get hashcode of the array using 'hashCode' method of array inthashCde = Arrays.hashCode(intArray); //print the hashCode System.out.println('The hashCode for input array:' + hashCde); } }Resultado:

O método hashCode calcula o código hash para a matriz fornecida como um argumento para ela.
perguntas frequentes
P # 1) O que são arrays java.util?
Responda: A classe java.util.Arrays se estende da classe java.lang.Object. A classe Arrays contém o método para representar arrays como uma lista. Ele também contém vários métodos para manipular os arrays, como classificação, pesquisa, representação de arrays como strings, etc.
P # 2) Qual classificação é usada na classificação de arrays em Java?
Responda: O método de classificação da classe Arrays em Java usa duas técnicas de classificação. Ele usa quicksort quando tipos primitivos são usados, enquanto que quando são usados objetos que implementam interface comparável, merge sort é usado.
P # 3) O que o método Arrays.sort () faz em Java?
Responda: O método Arrays.sort () em Java tem várias sobrecargas com as quais você pode realizar a classificação em arrays. Ele tem sobrecargas para classificar matrizes de diferentes tipos de dados primitivos.
Além disso, o método Arrays.sort () tem várias sobrecargas para classificar uma matriz em um intervalo especificado. Além disso, o método Arrays.sort () também nos permite classificar dependendo do comparador fornecido.
P # 4) O que são coleções e classes de arrays?
Responda: As coleções são dinâmicas por natureza e a classe Collections fornece métodos diretos que atuam nas coleções. Os arrays são de natureza estática e têm Arrays de classe que fornecem métodos para manipular arrays.
Mas esses não são métodos diretos, ou seja, os objetos Array não podem invocar esses métodos. Em vez disso, um objeto de matriz é passado como um argumento para esses métodos.
Conclusão
A classe Arrays pertence ao pacote java.util e estende-se da classe java.lang.Object. A classe Arrays contém métodos usados para manipular arrays. Esses métodos incluem aqueles usados para classificar matrizes, pesquisar um elemento específico em matrizes, preencher a matriz com um valor específico, métodos para comparar matrizes, etc.
Cada um desses métodos tem várias sobrecargas que permitem ao programador invocar esses métodos em arrays de diferentes tipos de dados e também em arrays parciais ou inteiros.
Neste tutorial, discutimos a maioria dos métodos da classe arrays. Também vimos uma breve descrição e exemplos dos principais métodos. Esses exemplos podem ser replicados para vários tipos de dados e deixamos para você.
=> Visite aqui para aprender Java do zero.
Leitura recomendada
- Tutorial de comprimento de array Java com exemplos de código
- Jagged Array In Java - Tutorial com exemplos
- Tutorial JAVA para iniciantes: mais de 100 tutoriais práticos em vídeo Java
- O que é Java Vector | Tutorial da classe Java Vector com exemplos
- Como classificar uma matriz em Java - Tutorial com exemplos
- Reverter uma matriz em Java - 3 métodos com exemplos
- Array genérico de Java - como simular matrizes genéricas em Java?
- Java Copy Array: como copiar / clonar um array em Java