Operações Comuns com Arrays em Java

Os arrays em si não possuem muitos métodos. O objeto array expõe um campo (length) e um método (clone()). Todo o restante — impressão, preenchimento, busca, comparação — está na classe utilitária java.util.Arrays, que abordaremos em profundidade no próximo capítulo. Este capítulo é um panorama das operações do dia a dia: o que fazem e qual chamada utilizar.

Esta página cobre a leitura do tamanho, impressão, preenchimento, comparação, busca, cópia e conversão de um array para uma List. Para cada tarefa geralmente existe uma chamada idiomática — o objetivo é reconhecer qual usar.

Tamanho

int[] data = {3, 1, 4, 1, 5, 9, 2, 6};
System.out.println(data.length);   // 8

Campo, não método — sem parênteses. length é fixo após a criação do array; para "aumentar" um array, você aloca um novo e copia (veja Copiando abaixo). Note que length é um campo nos arrays, enquanto String e coleções como List usam um método length() ou size() — uma fonte comum de confusão.

Imprimindo um array

System.out.println(arr) imprime algo como [I@1540e19d — o nome da classe e o hash. Isso raramente é o que você deseja. Use Arrays.toString:

import java.util.Arrays;

int[] data = {3, 1, 4, 1, 5};
System.out.println(Arrays.toString(data));   // [3, 1, 4, 1, 5]

Para arrays 2D, use Arrays.deepToString:

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

Preenchimento

Para definir todos os elementos com o mesmo valor:

int[] zeros = new int[5];
Arrays.fill(zeros, 7);              // {7, 7, 7, 7, 7}

A forma com intervalo preenche apenas [fromIndex, toIndex):

int[] data = new int[10];
Arrays.fill(data, 3, 7, 1);         // ones in positions 3, 4, 5, 6

Igualdade

== em arrays compara referências, não conteúdo. Para igualdade elemento a elemento, use Arrays.equals:

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a == b);                    // false (different objects)
System.out.println(Arrays.equals(a, b));       // true

Para arrays aninhados, use Arrays.deepEquals. Para semântica segura com null, ambos os auxiliares consideram null == null como true.

Busca

Uma varredura linear com um laço clássico é adequada para arrays pequenos ou de ordem desconhecida:

int[] data = {7, 3, 9, 1, 5};
int target = 9;
int found = -1;
for (int i = 0; i < data.length; i++) {
  if (data[i] == target) { found = i; break; }
}

Para um array ordenado, Arrays.binarySearch é O(log n):

int[] sorted = {1, 3, 5, 7, 9};
int idx = Arrays.binarySearch(sorted, 7);   // 3

Se o valor não estiver presente, binarySearch retorna um número negativo que codifica onde ele estaria: -(insertionPoint) - 1. Portanto, um retorno de -8 significa "não encontrado, pertence ao índice 7." Para converter no ponto de inserção: int insert = -(result) - 1;.

Copiando

Para obter um novo array com o mesmo conteúdo:

int[] data = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(data, data.length);

Para redimensionar durante a cópia — preenche com valores padrão se for maior, trunca se for menor:

int[] longer  = Arrays.copyOf(data, 8);    // {1, 2, 3, 4, 5, 0, 0, 0}
int[] shorter = Arrays.copyOf(data, 3);    // {1, 2, 3}

Para copiar um intervalo:

int[] middle = Arrays.copyOfRange(data, 1, 4);   // {2, 3, 4}

from é inclusivo, to é exclusivo — a convenção habitual de intervalo semi-aberto do Java.

O único método de cópia que está no próprio array é clone():

int[] data = {1, 2, 3};
int[] dup  = data.clone();          // {1, 2, 3}, a separate array

clone() faz uma cópia rasa: para um array de objetos (ou um array 2D, que é um array de arrays) as referências internas são compartilhadas, não duplicadas. Há mais detalhes sobre cópia — incluindo System.arraycopy e cópias profundas — no capítulo dedicado Copiando arrays.

Convertendo para uma List

Arrays.asList(...) envolve um array (de referências) como uma List de tamanho fixo:

String[] arr = {"a", "b", "c"};
List<String> list = Arrays.asList(arr);

É de tamanho fixo: add/remove lançam UnsupportedOperationException, mas você pode usar list.set(...). Note que asList não funciona com arrays primitivos como esperado — Arrays.asList(new int[]{1, 2, 3}) produz uma List<int[]> de comprimento 1, não uma List<Integer>. Para primitivos, use streams:

import java.util.stream.IntStream;

int[] nums = {1, 2, 3};
List<Integer> boxed = IntStream.of(nums).boxed().toList();

Hashing

Arrays.hashCode(arr) produz um hash baseado no conteúdo que você pode usar em implementações de equals/hashCode de uma classe que o contenha:

int[] data = {1, 2, 3};
int h = Arrays.hashCode(data);

Para arrays aninhados, use Arrays.deepHashCode.

Um exemplo prático

O que vem a seguir

Os auxiliares que você acabou de usar — toString, fill, equals, copyOf, binarySearch, sort — todos estão na mesma classe: java.util.Arrays. O próximo capítulo examina a classe utilitária Arrays sistematicamente, incluindo partes que deixamos de lado aqui.

Prática