Classe Arrays: sort, fill, copyOf, equals

1. Introdução

Arrays em Java são uma ferramenta poderosa, mas a sintaxe básica rapidamente cai na rotina. Para ajudar, existe a classe java.util.Arrays — um conjunto de métodos estáticos para trabalhar com arrays: ordenação, cópia, comparação, exibição formatada e mais. Não é necessário criar instâncias — todos os métodos são estáticos e chamados pelo nome da classe.

Para usar os métodos, adicione o import no início do arquivo:

import java.util.Arrays;

Se você esquecer o import, o compilador reclamará que Arrays “não encontrado” — não é bug, é o comportamento esperado sem o import.

2. Ordenação de array: Arrays.sort

Como funciona Arrays.sort

Sintaxe

Arrays.sort(massiv);
Arrays.sort(massiv, nachal’nyyIndeks, konechnyyIndeks);

O método ordena no próprio array — altera o array original e não retorna um novo. Quer preservar a ordem original? Copie o array primeiro.

Exemplo: ordenando um array de inteiros

int[] scores = {5, 2, 9, 1, 7};
Arrays.sort(scores); // Ordena em ordem crescente

System.out.println("Array ordenado: " + Arrays.toString(scores));
// Vai imprimir: [1, 2, 5, 7, 9]

Exemplo: ordenando um array de strings

String[] names = {"Vasya", "Petya", "Anya", "Igor"};
Arrays.sort(names);

System.out.println(Arrays.toString(names));
// [Anya, Igor, Petya, Vasya]

Importante: strings são ordenadas lexicograficamente (por ordem alfabética); números — em ordem crescente.

Ordenando parte do array

int[] arr = {7, 5, 3, 1, 9, 8};
Arrays.sort(arr, 1, 4); // ordena os elementos do índice 1 até 3 inclusive (4 não é incluído)

System.out.println(Arrays.toString(arr));
// [7, 1, 3, 5, 9, 8]

Características

• Ordenação in-place: o array original é modificado.
• Números — em ordem crescente; strings — por ordem alfabética.
• Para objetos complexos, use as sobrecargas com um Comparator.

3. Preenchimento do array: Arrays.fill

Sintaxe

Arrays.fill(massiv, znachenie);
Arrays.fill(massiv, nachal’nyyIndeks, konechnyyIndeks, znachenie);

O método preenche todos os elementos, ou a parte indicada, com o mesmo valor.

int[] marks = new int[5];
Arrays.fill(marks, 3); // Agora todos os elementos valem 3
System.out.println(Arrays.toString(marks)); // [3, 3, 3, 3, 3]

Preenchendo parte do array

int[] arr = new int[10];
Arrays.fill(arr, 2, 5, 7); // Preenche os elementos dos índices 2 a 4 inclusive (5 não é incluído)
System.out.println(Arrays.toString(arr));
// [0, 0, 7, 7, 7, 0, 0, 0, 0, 0]

Preenchendo um array de strings

String[] guests = new String[4];
Arrays.fill(guests, "Vazio");
System.out.println(Arrays.toString(guests)); // [Vazio, Vazio, Vazio, Vazio]

4. Cópia de array: Arrays.copyOf e Arrays.copyOfRange

Arrays.copyOf

Sintaxe

Arrays.copyOf(iskhodnyyMassiv, novayaDlina);

Cria um novo array e copia os elementos do original. Se o novo comprimento for maior que o original, o “resto” é preenchido com os valores padrão (0 para int, null para tipos de referência).

int[] original = {1, 2, 3};
int[] copy = Arrays.copyOf(original, 5);
System.out.println(Arrays.toString(copy)); // [1, 2, 3, 0, 0]

Reduzindo o array

int[] shortCopy = Arrays.copyOf(original, 2);
System.out.println(Arrays.toString(shortCopy)); // [1, 2]

Arrays.copyOfRange

Sintaxe

Arrays.copyOfRange(iskhodnyyMassiv, nachal’nyyIndeks, konechnyyIndeks);

int[] arr = {10, 20, 30, 40, 50};
int[] mid = Arrays.copyOfRange(arr, 1, 4); // Copia os elementos dos índices 1 a 3
System.out.println(Arrays.toString(mid)); // [20, 30, 40]

5. Comparação de arrays: Arrays.equals e Arrays.deepEquals

Em Java, não se comparam arrays com == — assim você compara referências, não o conteúdo:

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a == b); // false!

Como comparar o conteúdo?

Arrays.equals(massiv1, massiv2);
Arrays.deepEquals(matritsa1, matritsa2);

System.out.println(Arrays.equals(a, b)); // true

Para arrays unidimensionais, use Arrays.equals; para bidimensionais e mais profundos — Arrays.deepEquals.

Exemplo: comparando arrays bidimensionais

int[][] matrix1 = {{1, 2}, {3, 4}};
int[][] matrix2 = {{1, 2}, {3, 4}};

System.out.println(Arrays.equals(matrix1, matrix2));     // false!
System.out.println(Arrays.deepEquals(matrix1, matrix2)); // true

6. Exibição legível do array: Arrays.toString e Arrays.deepToString

Imprimir o array diretamente gera uma string pouco legível:

int[] arr = {1, 2, 3};
System.out.println(arr); // [I@7a81197d

Sintaxe

Arrays.toString(massiv);
Arrays.deepToString(matritsa);

System.out.println(Arrays.toString(arr)); // [1, 2, 3]

int[][] matrix = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepToString(matrix)); // [[1, 2], [3, 4]]

7. Erros comuns ao trabalhar com a classe Arrays

Erro nº 1: tentar comparar arrays com ==
Arrays são objetos, e == compara apenas as referências. Mesmo com valores iguais, o resultado será false. Use Arrays.equals (para unidimensionais) ou Arrays.deepEquals (para multidimensionais).

Erro nº 2: esquecer que a ordenação modifica o array “no lugar”
Se você precisa da ordem original, primeiro faça uma cópia com Arrays.copyOf e só depois ordene a cópia. Caso contrário, o original perderá a sua ordem.

Erro nº 3: entender incorretamente os limites em Arrays.fill e Arrays.copyOfRange
Os métodos usam um intervalo semiaberto: o índice direito não é incluído. Por exemplo, Arrays.fill(arr, 2, 5, 9) preencherá os índices 2, 3, 4, e não tocará o elemento de índice 5.

Erro nº 4: tentar imprimir o array diretamente
Chamar System.out.println(arr) imprime uma representação técnica. Use Arrays.toString para unidimensionais e Arrays.deepToString para arrays multidimensionais.

Erro nº 5: comparar arrays multidimensionais com Arrays.equals
O método compara apenas o nível superior (as referências para os arrays internos). Para comparar o conteúdo, use Arrays.deepEquals.

1

Pesquisa/teste

Arrays, nível 7, lição 5

Indisponível

Arrays

Introdução a arrays

Abrir