Clase utilitaria Arrays de Java

java.util.Arrays es la colección de funciones auxiliares para arrays de la biblioteca estándar. Es una clase final con solo métodos static — nunca se instancia, simplemente se llaman sus métodos directamente: Arrays.sort(...), Arrays.toString(...), etc. Una vez que conoces su contenido, el código que escribes para manejar arrays se vuelve mucho más corto.

Este capítulo es un recorrido guiado. La ordenación y la copia tienen sus propios capítulos; aquí nos enfocamos en el resto.

Importación

import java.util.Arrays;

Casi todos los ejemplos siguientes asumen esta importación.

toString y deepToString

Convierte un array en una cadena legible. toString maneja arrays unidimensionales:

int[] data = {3, 1, 4};
String s = Arrays.toString(data);   // "[3, 1, 4]"

deepToString formatea recursivamente arrays anidados:

int[][] grid = {{1, 2}, {3, 4}};
String s = Arrays.deepToString(grid);   // "[[1, 2], [3, 4]]"

Ambos funcionan con tipos de elementos primitivos y de objeto.

equals y deepEquals

== compara referencias de arrays. Para comparar contenidos:

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
boolean same = Arrays.equals(a, b);   // true

Para arrays anidados usa deepEquals:

int[][] g1 = {{1, 2}, {3, 4}};
int[][] g2 = {{1, 2}, {3, 4}};
boolean same = Arrays.deepEquals(g1, g2);   // true

Ambos consideran que null == null es true.

hashCode y deepHashCode

Hashes basados en contenido, útiles cuando una clase envuelve un array y necesita equals/hashCode:

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

Si sobreescribes equals para usar Arrays.equals, debes sobreescribir hashCode para usar Arrays.hashCode y mantener el contrato.

fill

Establece todos los elementos con un valor, o establece un rango:

int[] data = new int[5];
Arrays.fill(data, 7);              // {7, 7, 7, 7, 7}
Arrays.fill(data, 1, 4, 0);        // zero indexes 1..3

sort y parallelSort

Ordenación en sitio, ascendente:

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

Para arrays muy grandes puedes usar parallelSort para distribuir el trabajo en múltiples núcleos. La historia completa sobre ordenación — primitivos, objetos, órdenes personalizados — está en el capítulo Ordenar arrays.

binarySearch

Encuentra un elemento en un array ordenado en O(log n):

int[] sorted = {1, 3, 5, 7, 9};
int idx = Arrays.binarySearch(sorted, 5);   // 2
int miss = Arrays.binarySearch(sorted, 6);  // negative — encodes insertion point

Si el elemento no está presente, el valor de retorno es -(insertionPoint) - 1. Así, miss == -4 significa que el 6 pertenecería al índice 3. Si la entrada no está ordenada, el resultado es indefinido — ordena primero.

copyOf y copyOfRange

Devuelven un nuevo array, copiando valores de uno existente:

int[] data = {1, 2, 3, 4, 5};
int[] all   = Arrays.copyOf(data, data.length);    // exact copy
int[] grown = Arrays.copyOf(data, 8);              // padded with zeros
int[] slice = Arrays.copyOfRange(data, 1, 4);      // {2, 3, 4}

Estos se tratan en detalle en Copiar 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);

La lista está respaldada por el array — list.set(0, "z") también cambia arr[0]. El tamaño es fijo, por lo que add/remove lanzan excepciones. Con arrays primitivos no hace lo que esperarías: Arrays.asList(new int[]{1, 2, 3}) produce una List<int[]> de longitud uno. Para primitivos, conviértelos a boxed primero con streams.

stream

Obtén un stream de cualquier array numérico o de objetos:

int[] nums = {3, 1, 4, 1, 5};
int sum = Arrays.stream(nums).sum();
double avg = Arrays.stream(nums).average().orElse(0);

Para arrays de objetos, Arrays.stream(arr) devuelve un Stream<T>. También existen formas con rango limitado — Arrays.stream(arr, from, to).

setAll y parallelSetAll

Rellena un array usando una función del índice:

int[] squares = new int[6];
Arrays.setAll(squares, i -> i * i);
// {0, 1, 4, 9, 16, 25}

Usa setAll cuando quieras una secuencia derivada y un bucle for solo añadiría ruido.

compare y mismatch (Java 9+)

Arrays.compare(a, b) devuelve negativo, cero o positivo — orden lexicográfico sobre los elementos:

int[] a = {1, 2, 3};
int[] b = {1, 2, 4};
int cmp = Arrays.compare(a, b);   // negative — a is smaller

Arrays.mismatch(a, b) devuelve el índice del primer elemento diferente, o -1 si son iguales:

int diff = Arrays.mismatch(a, b);   // 2

Cuando un array es un prefijo propio del otro, el más corto se considera "menor" por compare, y mismatch devuelve la longitud del array más corto:

int[] s = {1, 2};
int[] l = {1, 2, 3};
Arrays.compare(s, l);    // negative — s is a prefix, so it sorts first
Arrays.mismatch(s, l);   // 2 — they agree up to index 2, then s runs out

Estos son útiles cuando necesitas orden o "en qué punto divergieron" sin escribir el bucle a mano.

Errores comunes

Algunas trampas son lo suficientemente frecuentes como para listarlas en un solo lugar:

• == no es comparación de contenido. a == b es true solo cuando ambos nombres apuntan al mismo objeto array. Usa Arrays.equals (o Arrays.deepEquals para arrays anidados) para comparar contenidos.
• toString es superficial. Arrays.toString(grid) sobre un int[][] imprime algo como [[I@1b6d3586, ...] — los arrays internos usan su Object.toString predeterminado. Usa Arrays.deepToString siempre que un array contenga otros arrays.
• asList con un array primitivo te sorprende. Arrays.asList(new int[]{1, 2, 3}) es una List<int[]> de un elemento, no una List<Integer> de longitud tres, porque int[] es un único objeto. Usa Arrays.stream(arr).boxed().toList() (Java 16+) para obtener la lista que querías.
• asList es de tamaño fijo. Es una vista sobre el array original, por lo que set funciona pero add y remove lanzan UnsupportedOperationException. Envuélvelo en new ArrayList<>(Arrays.asList(...)) si necesitas hacerlo crecer.
• binarySearch necesita un array ordenado. Con entrada sin ordenar, el resultado es indefinido — no lanza excepción, simplemente devuelve un índice incorrecto. Ordena primero.

Un ejemplo completo

La demo siguiente combina la mayoría de los métodos. Ejecútala y compara la salida con los comentarios anteriores — binarySearch devuelve 5 para el valor 5, el resultado negativo para un elemento no presente, y la lista [red, green, blue] de asList:

Qué sigue

Hemos usado Arrays.sort solo de pasada. El siguiente capítulo, Ordenar arrays, profundiza en cómo funciona la ordenación para primitivos frente a objetos, ascendente frente a descendente, y cómo ordenar con tus propios criterios usando un Comparator.

Práctica