Operaciones comunes con arrays en Java

Los arrays en sí no tienen muchos métodos. El objeto array expone un campo (length) y un método (clone()). Todo lo demás — imprimir, rellenar, buscar, comparar — vive en la clase utilitaria java.util.Arrays, que cubriremos en profundidad en el siguiente capítulo. Este capítulo es un recorrido por las operaciones del día a día: qué hacen y cuál usar en cada caso.

Esta página cubre cómo leer el tamaño, imprimir, rellenar, comparar, buscar, copiar y convertir un array a una List. Para cada tarea suele haber una llamada idiomática — el objetivo es reconocer cuál es.

Longitud

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

Es un campo, no un método — sin paréntesis. length es fijo una vez que el array se crea; para "crecer" un array hay que asignar uno nuevo y copiar (ver Copiar más abajo). Ten en cuenta que length es un campo en los arrays, mientras que String y colecciones como List usan un método length() o size() — una fuente común de confusión.

Imprimir un array

System.out.println(arr) imprime algo como [I@1540e19d — el nombre de la clase y el hash. Casi nunca es lo que deseas. Usa 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 usa Arrays.deepToString:

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

Rellenar

Para asignar el mismo valor a cada posición:

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

La forma con rango rellena solo [fromIndex, toIndex):

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

Igualdad

== en arrays compara referencias, no contenidos. Para igualdad elemento a elemento, usa 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 anidados, usa Arrays.deepEquals. En cuanto a semántica null-safe, ambos helpers consideran que null == null es true.

Búsqueda

Un recorrido lineal con un bucle clásico es adecuado para arrays pequeños o de orden desconocido:

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 un array ordenado, Arrays.binarySearch es O(log n):

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

Si el valor no está presente, binarySearch devuelve un número negativo que codifica dónde iría: -(insertionPoint) - 1. Así, un retorno de -8 significa "no encontrado, corresponde al índice 7." Para obtener el punto de inserción: int insert = -(result) - 1;.

Copiar

Para obtener un nuevo array con los mismos contenidos:

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

Para cambiar el tamaño al copiar — rellena con valores por defecto si es más largo, trunca si es más corto:

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 un fragmento:

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

from es inclusivo, to es exclusivo — la convención habitual de intervalo semiabierto en Java.

El único método de copia que pertenece al propio array es clone():

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

clone() hace una copia superficial: para un array de objetos (o un array 2D, que es un array de arrays) las referencias internas se comparten, no se duplican. Hay más profundidad sobre la copia — incluyendo System.arraycopy y copias profundas — en el capítulo dedicado Copiar arrays.

Convertir a una List

Arrays.asList(...) envuelve un array (de referencias) como una List de tamaño fijo:

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

Es de tamaño fijo: add/remove lanzan UnsupportedOperationException, pero sí puedes hacer list.set(...). Ten en cuenta que asList no funciona con arrays de primitivos como esperarías — Arrays.asList(new int[]{1, 2, 3}) produce una List<int[]> de longitud 1, no una List<Integer>. Para primitivos, usa streams:

import java.util.stream.IntStream;

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

Hashing

Arrays.hashCode(arr) produce un hash basado en el contenido que puedes usar en implementaciones de equals/hashCode de una clase contenedora:

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

Para arrays anidados, usa Arrays.deepHashCode.

Ejemplo práctico

Qué sigue

Los helpers que acabas de usar — toString, fill, equals, copyOf, binarySearch, sort — todos viven en la misma clase: java.util.Arrays. El siguiente capítulo examina la clase utilitaria Arrays de forma sistemática, incluyendo partes que omitimos aquí.

Práctica