La clase Arrays: ordenar, buscar y comparar

La clase Arrays agrupa métodos estáticos para operar con arrays, como ordenar, buscar, copiar o comparar sus elementos.

Los arrays son estructuras rígidas y no incorporan métodos propios para realizar estas operaciones.

Son estructuras rígidas. Si quieres ordenar los números de un array, el array no sabe hacerlo. Si quieres buscar un dato, tienes que recorrerlo tú. Si intentas imprimirlo directamente, te sale un código raro como [I@15db9742.

Antiguamente, tenías que escribir tú mismo algoritmos de ordenación (como el Burbuja o Quicksort). Hoy en día, eso está prohibido en producción. Java ya trae una navaja suiza optimizada al máximo para hacer este trabajo sucio: la clase java.util.Arrays.

Esta clase es un conjunto de métodos estáticos (herramientas) que nos hacen la vida mucho más fácil.

Imprimir un array

Seguro que ya has intentado esto y te has llevado un chasco:

int[] numeros = {1, 2, 3};
System.out.println(numeros); // Salida: [I@6d06d69c (Referencia de memoria)

Como los arrays heredan la representación de Object, Java muestra el nombre interno del tipo y un hash en hexadecimal. Para ver el contenido, usamos Arrays.toString():

import java.util.Arrays; // ¡Importante!

System.out.println(Arrays.toString(numeros));
// Salida: [1, 2, 3]

Ordenación con Arrays.sort()

Ordenar datos es una de las tareas más costosas en computación. No reinventes la rueda. El método sort de Java es extremadamente rápido (usa una variante de Dual-Pivot Quicksort para primitivos y Timsort para objetos).

int[] desordenados = {5, 1, 9, 3};

// Ordena el array original (Modifica el array, no devuelve uno nuevo)
Arrays.sort(desordenados);

System.out.println(Arrays.toString(desordenados));
// Salida: [1, 3, 5, 9]

Ordenar partes del array

También podemos ordenar solo un rango (fromIndex inclusivo, toIndex exclusivo).

// Ordenar solo del índice 0 al 2
Arrays.sort(arr, 0, 3);

Búsqueda binaria (binarySearch)

Si quieres buscar un elemento en un array, lo normal es hacer un for y mirar uno a uno. Esto se llama Búsqueda Lineal y tiene un coste de . Si tienes 1 millón de datos, en el peor caso harás 1 millón de comprobaciones.

La Búsqueda Binaria es mucho más inteligente. Va dividiendo el array por la mitad. ¿Es mayor o menor? Y descarta la mitad. Su coste es . En 1 millón de datos, encuentra el objetivo en apenas 20 pasos.

Para usarla:

int[] numeros = {10, 20, 30, 40, 50};

// Devuelve el índice donde está el elemento
int posicion = Arrays.binarySearch(numeros, 30);
System.out.println("El 30 está en la posición: " + posicion); // 2

¿Qué pasa si no lo encuentra?

El método devuelve un número negativo. Pero no es un negativo cualquiera. Devuelve: (-(punto de inserción) - 1)

Es decir, te dice dónde debería ir el número si quisieras insertarlo ordenadamente.

Comparación (equals y compare)

Recuerda que array1 == array2 compara si son el mismo objeto. Si queremos saber si tienen el mismo contenido, usamos Arrays.equals().

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};

System.out.println(a == b);       // false (Distintos objetos)
System.out.println(Arrays.equals(a, b)); // true (Mismo contenido)

Desde Java 9, también tenemos Arrays.compare(a, b), que devuelve:

• 0: Si son idénticos.
• < 0: Si a es “menor” (léxicamente) que b.
• > 0: Si a es “mayor” que b.

Rellenar y copiar (fill y copyOf)

Otras dos utilidades que nos salvan de escribir bucles for:

• Arrays.fill(arr, valor): Rellena todo el array (o un rango) con un mismo valor. Útil para resetear datos.
• Arrays.copyOf(original, nuevoTamano): Crea un nuevo array copiando los datos del original. Si el nuevo tamaño es mayor, completa las posiciones con el valor por defecto del tipo (0, false o null).

int[] origen = {1, 2, 3};
int[] masGrande = Arrays.copyOf(origen, 5);
// masGrande es [1, 2, 3, 0, 0]