Arrays en Java: declarar, inicializar, acceder y recorrer

Un array es una lista de tamaño fijo

Un array en Java guarda un número fijo de valores del mismo tipo, dispuestos en orden y accesibles por su posición. "Fijo" es la palabra clave: una vez que creas un array, su longitud nunca cambia. Y "mismo tipo": un int[] solo guarda valores int, un String[] solo guarda cadenas. Esa rigidez es el precio que pagas a cambio de que los arrays sean rápidos y compactos en memoria.

Declaras un tipo de array poniendo [] después del tipo del elemento, y luego o le asignas un literal o reservas uno con new:

public class Main {
    public static void main(String[] args) {
        int[] scores = {82, 91, 73, 88};
        String[] names = {"Ada", "Boris", "Chen"};

        System.out.println(scores[0]);
        System.out.println(names[1]);
    }
}

Los corchetes pueden ir después del tipo (int[] scores) o después del nombre (int scores[]). Ambas formas compilan, pero int[] scores es el estilo idiomático de Java - pon los [] junto al tipo, que es donde corresponden.

Crear un array con new

Cuando aún no conoces los valores pero sí conoces el tamaño, usa new. Esto reserva las posiciones y las rellena con el valor por defecto del tipo:

public class Main {
    public static void main(String[] args) {
        int[] nums = new int[5];
        boolean[] flags = new boolean[3];
        String[] words = new String[2];

        System.out.println(nums[0]);
        System.out.println(flags[0]);
        System.out.println(words[0]);
    }
}

Los valores por defecto no son basura aleatoria - Java inicializa cada elemento a cero. Los tipos numéricos empiezan en 0 (o 0.0), boolean empieza en false, y los tipos de referencia como String empiezan en null. Ese null conviene recordarlo: un String[] recién reservado está lleno de nulls, y llamar a un método sobre uno de ellos lanza un NullPointerException.

La indexación empieza en cero

Lees y escribes elementos por índice, contando desde 0. El último índice válido es siempre length - 1:

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        System.out.println(colors[0]);
        System.out.println(colors[2]);

        colors[1] = "yellow";
        System.out.println(colors[1]);
    }
}

A diferencia de los arrays de algunos lenguajes de scripting, salirte del rango no te devuelve silenciosamente null ni undefined - lanza una excepción. Prueba a leer un índice que no existe:

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30};
        System.out.println(nums[5]);
    }
}

Ese programa se cae con:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 3

Este es uno de los errores más comunes entre principiantes. La solución casi siempre es un error de uno en uno (off-by-one) en la condición de un bucle - usar <= donde querías <.

length es un campo, no un método

Cada array lleva su tamaño en un campo length. Atención: sin paréntesis.

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30, 40};
        System.out.println(nums.length);
    }
}

Aquí va un detalle que pilla a todo el mundo al menos una vez: los arrays usan .length (un campo), pero String usa .length() (un método). Escribir nums.length() en un array es un error de compilación, y escribir text.length en una cadena también. La misma palabra, reglas distintas - la del array no lleva paréntesis.

Recorrer un array

Aprendiste el bucle for-each en la página anterior, y es la forma más limpia de leer todos los elementos cuando no necesitas el índice:

public class Main {
    public static void main(String[] args) {
        int[] scores = {82, 91, 73, 88};

        int total = 0;
        for (int score : scores) {
            total += score;
        }

        System.out.println("Total: " + total);
        System.out.println("Average: " + (total / scores.length));
    }
}

Cuando necesitas el índice - para imprimir números de posición, modificar elementos en el sitio o iterar hacia atrás - recurre al clásico bucle for indexado usando length como límite:

public class Main {
    public static void main(String[] args) {
        String[] names = {"Ada", "Boris", "Chen"};

        for (int i = 0; i < names.length; i++) {
            System.out.println(i + ": " + names[i]);
        }
    }
}

La condición es i < names.length, no <=. Usar <= da un paso de más y lanza la excepción de fuera de rango de la sección anterior. Una regla rápida: for-each cuando solo lees valores, for indexado cuando necesitas la posición o quieres escribir de vuelta en el array.

Arrays multidimensionales

Un array 2D es en realidad un array de arrays - imagínalo como una cuadrícula de filas y columnas. Añades un segundo par de corchetes:

public class Main {
    public static void main(String[] args) {
        int[][] grid = {
            {1, 2, 3},
            {4, 5, 6}
        };

        System.out.println(grid[0][2]);
        System.out.println(grid[1][0]);

        for (int[] row : grid) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

grid[fila][columna] selecciona una sola celda. Como cada fila es su propio array, grid.length es el número de filas y grid[0].length es el número de columnas de la primera fila. Las filas ni siquiera tienen que tener la misma longitud (eso se llama array irregular o jagged), aunque la mayoría de las cuadrículas son rectangulares.

La clase de utilidad Arrays

Los arrays en sí casi no tienen métodos - no puedes ordenar ni imprimir uno directamente de forma útil. Java proporciona una clase de utilidad java.util.Arrays llena de ayudantes estáticos precisamente para esto:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {5, 2, 8, 1, 9};

        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));

        int[] copy = Arrays.copyOf(nums, 7);
        System.out.println(Arrays.toString(copy));

        int found = Arrays.binarySearch(nums, 8);
        System.out.println("Index of 8: " + found);
    }
}

Aquí hay un par de cosas en las que apoyarse. Arrays.toString(arr) es la forma correcta de imprimir un array - imprimir uno directamente te da una cadena inútil como [I@1b6d3586. Arrays.sort ordena en el sitio. Arrays.copyOf es como se "redimensiona": devuelve un array nuevo de la longitud que pidas, rellenando con valores por defecto (las dos posiciones extra de arriba son 0). Y Arrays.binarySearch solo funciona correctamente sobre un array que ya esté ordenado.

Arrays frente a ArrayList

Usa un array normal cuando el tamaño se conoce de antemano y no va a cambiar - un conjunto fijo de días de la semana, un tablero de juego, datos de píxeles. Los arrays son rápidos y ligeros, pero su longitud fija es una limitación real: no puedes añadir un séptimo elemento a un array de longitud 6 sin construir uno completamente nuevo.

En cuanto necesitas añadir y eliminar elementos con libertad, un array se vuelve incómodo. Para eso está ArrayList - una lista redimensionable que puede crecer y que se encarga de la copia por ti.

Siguiente: ArrayList

Cuando no sabes cuántos elementos tendrás, o ese número cambia mientras tu programa se ejecuta, un array de longitud fija se interpone en el camino. ArrayList es la respuesta de Java: una lista que crece y se encoge según se necesite, con métodos add y remove en lugar de hacer malabares con índices. Eso es lo que viene a continuación.