Copiando Arrays em Java

Atribuir uma variável de array a outra não copia nada — apenas faz com que dois nomes apontem para o mesmo array subjacente:

int[] a = {1, 2, 3};
int[] b = a;
b[0] = 99;
System.out.println(a[0]);   // 99 — same array

Para obter uma cópia independente, você precisa solicitá-la explicitamente. Java oferece várias formas, cada uma adequada a uma situação diferente: duplicata completa, redimensionamento durante a cópia, fatia, cópia entre dois arrays existentes. A maioria delas está na classe utilitária Arrays, portanto um import java.util.Arrays; é assumido nos exemplos abaixo.

Arrays.copyOf — duplicar ou redimensionar

Recebe a origem e um comprimento de destino. Se o novo comprimento coincidir, você obtém uma cópia limpa. Se for maior, os slots extras são preenchidos com valores padrão (0, false, null); se for menor, o final é descartado.

import java.util.Arrays;

int[] data = {1, 2, 3, 4, 5};
int[] same   = Arrays.copyOf(data, data.length);   // {1, 2, 3, 4, 5}
int[] grown  = Arrays.copyOf(data, 8);             // {1, 2, 3, 4, 5, 0, 0, 0}
int[] shrunk = Arrays.copyOf(data, 3);             // {1, 2, 3}

É assim que se "cresce" um array de tamanho imutável — aloca-se um maior e copia-se.

Arrays.copyOfRange — fatia

Copia um intervalo semi-aberto [from, to):

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

to pode ultrapassar o comprimento da origem — os slots extras voltam como padrão. Portanto, é possível fatiar e preencher em uma única chamada.

System.arraycopy — copiar para um array existente

O primitivo de mais baixo nível: copia um intervalo de um array para um intervalo de outro. Sem nova alocação, sem valor de retorno — ambos os arrays já devem existir.

int[] src = {10, 20, 30, 40, 50};
int[] dst = new int[8];
System.arraycopy(src, 1, dst, 3, 3);
// dst is now {0, 0, 0, 20, 30, 40, 0, 0}

Os argumentos são (src, srcStart, dst, dstStart, length). Use isso quando quiser colocar dados em um deslocamento específico, ou quando estiver movendo elementos dentro do mesmo array — System.arraycopy(arr, i, arr, i + 1, length - i - 1) desloca uma fatia para a direita por um, para abrir espaço para uma inserção. Intervalos sobrepostos dentro de um único array são suportados e tratados corretamente.

clone() — cópia completa rápida

Todo array possui um método clone() que retorna um novo array com o mesmo comprimento e conteúdo:

int[] data = {1, 2, 3};
int[] copy = data.clone();

Para arrays unidimensionais, clone() é a forma mais curta e clara de duplicar. O tipo de retorno é o mesmo que o da origem — sem necessidade de cast.

Para arrays multidimensionais, clone() é superficial: copia o array externo, mas as linhas ainda são as referências originais:

int[][] grid = {{1, 2}, {3, 4}};
int[][] shallow = grid.clone();
shallow[0][0] = 99;
System.out.println(grid[0][0]);   // 99 — same inner row

Para fazer uma cópia profunda de um array 2D, clone cada linha separadamente:

int[][] deep = new int[grid.length][];
for (int r = 0; r < grid.length; r++) deep[r] = grid[r].clone();

Uma versão com stream: Arrays.stream(grid).map(int[]::clone).toArray(int[][]::new).

Streams

Para arrays de objetos, Arrays.stream(arr).toArray(T[]::new) produz uma cópia:

String[] names = {"Ada", "Linus", "Grace"};
String[] copy = Arrays.stream(names).toArray(String[]::new);

Para arrays primitivos, use o stream especializado:

import java.util.stream.IntStream;

int[] data = {1, 2, 3, 4, 5};
int[] copy = IntStream.of(data).toArray();

Streams são mais pesados que copyOf ou clone() e existem principalmente para o caso de transformação — .map(...) ou .filter(...) no meio do pipeline — não para duplicação simples.

Cópias por referência vs. cópias profundas

Para primitivos, toda cópia é totalmente independente — os valores em si são duplicados. Para arrays de objetos, todos os métodos de cópia que cobrimos são superficiais: duplicam o array de referências, mas cada referência ainda aponta para o mesmo objeto que o original.

StringBuilder[] src = { new StringBuilder("hi") };
StringBuilder[] copy = src.clone();
copy[0].append(" there");
System.out.println(src[0]);   // "hi there" — same StringBuilder

Isso geralmente está correto — Strings, Integers e qualquer tipo imutável podem ser compartilhados com segurança. Se os elementos forem mutáveis e você precisar de objetos independentes, terá que copiá-los manualmente:

StringBuilder[] deep = new StringBuilder[src.length];
for (int i = 0; i < src.length; i++) deep[i] = new StringBuilder(src[i]);

Escolhendo um método de cópia

Um exemplo prático

O que vem a seguir

Agora você pode criar, percorrer, pesquisar, ordenar e copiar arrays — o kit completo de ferramentas para trabalhar com os contêineres de tamanho fixo do Java. A seguir está a parte sobre métodos: como empacotar código em unidades nomeadas e reutilizáveis que recebem parâmetros e retornam valores.

Prática