Copiar Arrays en Java

Asignar una variable de array a otra no copia nada — simplemente hace que dos nombres apunten al mismo array subyacente:

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

Para obtener una copia independiente debes solicitarla explícitamente. Java ofrece varias formas, cada una adecuada para una situación diferente: duplicado completo, cambio de tamaño al copiar, segmento, copia entre dos arrays existentes. La mayoría se encuentran en la clase utilitaria Arrays, por lo que se asume un import java.util.Arrays; en los ejemplos a continuación.

Arrays.copyOf — duplicar o cambiar tamaño

Recibe la fuente y una longitud de destino. Si la nueva longitud coincide, obtienes una copia limpia. Si es mayor, los espacios extra se rellenan con valores predeterminados (0, false, null); si es menor, se descarta el final.

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}

Así es como se "crece" un array de tamaño fijo — se asigna uno más grande y se copia.

Arrays.copyOfRange — segmento

Copia un rango semiabierto [from, to):

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

Se permite que to supere la longitud de la fuente — los espacios extra vuelven como valores predeterminados. Así puedes extraer un segmento y rellenarlo en una sola llamada.

System.arraycopy — copiar en un array existente

La primitiva de más bajo nivel: copia un rango de un array en un rango de otro. Sin nueva asignación, sin valor de retorno — ambos arrays deben existir previamente.

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}

Los argumentos son (src, srcStart, dst, dstStart, length). Úsalo cuando quieras colocar datos en un desplazamiento específico, o cuando estés moviendo elementos dentro del mismo array — System.arraycopy(arr, i, arr, i + 1, length - i - 1) desplaza un segmento una posición a la derecha para hacer espacio para una inserción. Los rangos solapados dentro de un mismo array están soportados y se manejan correctamente.

clone() — copia completa rápida

Cada array tiene un método clone() que devuelve un nuevo array con la misma longitud y contenido:

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

Para arrays unidimensionales, clone() es la forma más corta y clara de duplicar. El tipo de retorno es el mismo que el de la fuente — no se necesita conversión de tipo.

Para arrays multidimensionales, clone() es superficial: copia el array exterior, pero las filas siguen siendo las referencias originales:

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 hacer una copia profunda de un array 2D, clona cada fila por separado:

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

Una versión con streams: Arrays.stream(grid).map(int[]::clone).toArray(int[][]::new).

Streams

Para arrays de objetos, Arrays.stream(arr).toArray(T[]::new) produce una copia:

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

Para arrays de tipos primitivos, usa el stream especializado:

import java.util.stream.IntStream;

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

Los streams son más pesados que copyOf o clone() y existen principalmente para el caso de transformación — .map(...) o .filter(...) en medio de la cadena — no para duplicación simple.

Copias por referencia vs. copias profundas

Para tipos primitivos, cada copia es completamente independiente — los valores mismos se duplican. Para arrays de objetos, todos los métodos de copia que hemos visto son superficiales: duplican el array de referencias, pero cada referencia sigue apuntando al mismo objeto que el original.

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

Esto suele estar bien — Strings, Integers y cualquier cosa inmutable puede compartirse de forma segura. Si los elementos son mutables y necesitas objetos independientes, debes copiarlos tú mismo:

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

Elegir un método de copia

Un ejemplo práctico

Qué sigue

Ahora puedes crear, recorrer, buscar, ordenar y copiar arrays — el conjunto completo de herramientas para trabajar con los contenedores de tamaño fijo de Java. A continuación viene la parte sobre métodos: cómo empaquetar código en unidades con nombre y reutilizables que reciben parámetros y devuelven valores.

Práctica