1. Introducción
Los arrays en Java son una herramienta potente, pero la sintaxis básica enseguida se vuelve rutinaria. Ahí es donde entra en juego la clase java.util.Arrays — un conjunto de métodos estáticos para trabajar con arrays: ordenación, copia, comparación, salida formateada y más. No hace falta crear instancias — todos los métodos son estáticos y se invocan por el nombre de la clase.
Para utilizar los métodos, añade la importación al comienzo del archivo:
import java.util.Arrays;
Si olvidas la importación, el compilador se quejará de que Arrays «no se encuentra» — no es un bug, sino el comportamiento esperado sin el import.
2. Ordenación de un array: Arrays.sort
Cómo funciona Arrays.sort
Sintaxis
Arrays.sort(array);
Arrays.sort(array, startIndex, endIndex);El método ordena «in situ» — modifica el array original y no devuelve uno nuevo. ¿Quieres conservar el orden original? Copia el array primero.
Ejemplo: ordenar un array de enteros
int[] scores = {5, 2, 9, 1, 7};
Arrays.sort(scores); // Ordenamos en orden ascendente
System.out.println("Array ordenado: " + Arrays.toString(scores));
// Imprimirá: [1, 2, 5, 7, 9]
Ejemplo: ordenar un array de cadenas
String[] names = {"Vasya", "Petya", "Anya", "Igor’"};
Arrays.sort(names);
System.out.println(Arrays.toString(names));
// [Anya, Igor’, Petya, Vasya]
Importante: las cadenas se ordenan lexicográficamente (por orden alfabético) y los números en orden ascendente.
Ordenar una parte del array
int[] arr = {7, 5, 3, 1, 9, 8};
Arrays.sort(arr, 1, 4); // ordena los elementos desde el índice 1 hasta el 3 inclusive (el 4 no se incluye)
System.out.println(Arrays.toString(arr));
// [7, 1, 3, 5, 9, 8]
Particularidades
- Ordenación «in situ»: el array original cambia.
- Números: ascendente; cadenas: alfabético.
- Para objetos complejos, usa las sobrecargas con Comparator.
3. Relleno de un array: Arrays.fill
Sintaxis
Arrays.fill(array, value);
Arrays.fill(array, startIndex, endIndex, value);El método rellena todos los elementos o la parte indicada del array con el mismo valor.
int[] marks = new int[5];
Arrays.fill(marks, 3); // Todos los elementos ahora valen 3
System.out.println(Arrays.toString(marks)); // [3, 3, 3, 3, 3]
Rellenar una parte del array
int[] arr = new int[10];
Arrays.fill(arr, 2, 5, 7); // Rellenará los elementos desde el índice 2 hasta el 4 inclusive (el 5 no se incluye)
System.out.println(Arrays.toString(arr));
// [0, 0, 7, 7, 7, 0, 0, 0, 0, 0]
Rellenar un array de cadenas
String[] guests = new String[4];
Arrays.fill(guests, "Vacío");
System.out.println(Arrays.toString(guests)); // [Vacío, Vacío, Vacío, Vacío]
4. Copia de un array: Arrays.copyOf y Arrays.copyOfRange
Arrays.copyOf
Sintaxis
Arrays.copyOf(sourceArray, newLength);Crea un nuevo array y copia los elementos del original. Si la nueva longitud es mayor que la del original, la «cola» se rellena con los valores por defecto (0 para int, null para los de referencia).
int[] original = {1, 2, 3};
int[] copy = Arrays.copyOf(original, 5);
System.out.println(Arrays.toString(copy)); // [1, 2, 3, 0, 0]
Reducir un array
int[] shortCopy = Arrays.copyOf(original, 2);
System.out.println(Arrays.toString(shortCopy)); // [1, 2]
Arrays.copyOfRange
Sintaxis
Arrays.copyOfRange(sourceArray, startIndex, endIndex);int[] arr = {10, 20, 30, 40, 50};
int[] mid = Arrays.copyOfRange(arr, 1, 4); // Copiará los elementos desde el índice 1 hasta el 3
System.out.println(Arrays.toString(mid)); // [20, 30, 40]
5. Comparación de arrays: Arrays.equals y Arrays.deepEquals
En Java no se pueden comparar arrays con == — así se comparan las referencias, no el contenido:
int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a == b); // false!
¿Cómo comparar el contenido?
Arrays.equals(array1, array2);
Arrays.deepEquals(matrix1, matrix2);System.out.println(Arrays.equals(a, b)); // true
Para arrays unidimensionales usa Arrays.equals; para bidimensionales y de mayor profundidad, Arrays.deepEquals.
Ejemplo: comparar arrays bidimensionales
int[][] matrix1 = {{1, 2}, {3, 4}};
int[][] matrix2 = {{1, 2}, {3, 4}};
System.out.println(Arrays.equals(matrix1, matrix2)); // false!
System.out.println(Arrays.deepEquals(matrix1, matrix2)); // true
6. Salida legible de un array: Arrays.toString y Arrays.deepToString
Imprimir un array directamente dará una cadena ilegible:
int[] arr = {1, 2, 3};
System.out.println(arr); // [I@7a81197d
Sintaxis
Arrays.toString(array);
Arrays.deepToString(matrix);System.out.println(Arrays.toString(arr)); // [1, 2, 3]
int[][] matrix = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepToString(matrix)); // [[1, 2], [3, 4]]
7. Errores típicos al trabajar con la clase Arrays
Error n.º 1: intentar comparar arrays con ==
Los arrays son objetos, y == solo compara referencias. Incluso con valores iguales, el resultado será false. Usa Arrays.equals (para unidimensionales) o Arrays.deepEquals (para multidimensionales).
Error n.º 2: olvidar que la ordenación cambia el array «in situ»
Si necesitas el orden original, primero crea una copia con Arrays.copyOf y solo después ordena la copia. De lo contrario, el original perderá su orden.
Error n.º 3: malentender los límites en Arrays.fill y Arrays.copyOfRange
Estos métodos usan un rango semiabierto: el índice derecho no se incluye. Por ejemplo, Arrays.fill(arr, 2, 5, 9) rellenará los índices 2, 3, 4, y no tocará el elemento en el índice 5.
Error n.º 4: intentar imprimir un array directamente
Llamar a System.out.println(arr) imprime una representación técnica. Usa Arrays.toString para unidimensionales y Arrays.deepToString para arrays multidimensionales.
Error n.º 5: comparar arrays multidimensionales con Arrays.equals
Este método solo compara el nivel superior (las referencias a los arrays internos). Para comparar el contenido, usa Arrays.deepEquals.
GO TO FULL VERSION