Arrays en Java

Un array en Java es un contenedor de tamaño fijo que almacena una secuencia de valores del mismo tipo. Una vez que lo creas, su longitud nunca cambia, y cada posición puede guardar exactamente un valor: un int, un String, una referencia a cualquier objeto, cualquier cosa que encaje en el tipo declarado.

Los arrays son la base sobre la que se construyen el resto de las colecciones de Java (ArrayList, HashMap y demás). No son tan ergonómicos como esas clases de alto nivel, pero son rápidos, predecibles y los encontrarás en todas partes: argumentos de métodos, valores de retorno, código sensible al rendimiento.

Declarar un array

El tipo de un array es el tipo de elemento seguido de []:

int[] scores;       // an array of ints
String[] names;     // an array of String references
double[] prices;    // an array of doubles

Los corchetes también pueden ir después del nombre de la variable — int scores[]; — pero la forma int[] scores es mucho más común y es la que deberías usar.

Declarar una variable todavía no crea un array; solo le da a Java una ranura que puede contener una referencia a uno. La ranura comienza como null.

Crear un array con new

Para reservar el array, usa new con una longitud:

int[] scores = new int[5];

Esto reserva espacio para 5 ints. Java inicializa cada posición con el valor predeterminado del tipo:

• tipos numéricos → 0 (o 0.0)
• boolean → false
• char → '�' (el carácter nulo, punto de código 0 — no un espacio)
• tipos de referencia → null

Entonces scores contiene inmediatamente {0, 0, 0, 0, 0}. No existe estado "no inicializado" — una vez que has creado el array, cada posición tiene un valor definido.

Literales de array

Cuando conoces el contenido de antemano, usa un literal:

int[] scores = {90, 85, 73, 100, 62};
String[] colors = {"red", "green", "blue"};

La longitud se deduce del número de elementos. Esta forma solo es válida en la misma línea que la declaración — no puedes escribir scores = {90, 85}; después. Para eso, usa la forma explícita:

scores = new int[]{90, 85, 73, 100, 62};

Acceder a los elementos

Puedes leer y escribir elementos mediante un índice de base cero, usando corchetes:

int[] scores = {90, 85, 73, 100, 62};
System.out.println(scores[0]);   // 90
System.out.println(scores[4]);   // 62
scores[2] = 80;                  // replace 73 with 80

Los índices válidos van de 0 hasta length - 1. Un índice fuera de rango lanza ArrayIndexOutOfBoundsException en tiempo de ejecución — Java no devuelve silenciosamente un valor predeterminado ni envuelve el índice.

La propiedad length

Todo array tiene un campo length público y de solo lectura que informa su tamaño:

int[] scores = {90, 85, 73, 100, 62};
System.out.println(scores.length);   // 5

Ten en cuenta que es un campo, no un método — sin paréntesis. Esta es una de las pequeñas peculiaridades de Java: las cadenas usan .length(), los arrays usan .length. También se comportan de forma diferente a las colecciones (list.size()). Es fácil confundir las formas; el compilador te lo indicará.

length es fijo en el momento de la creación. Para "ampliar" un array debes reservar uno nuevo y copiar — consulta el capítulo Copiar arrays.

Los arrays guardan referencias, no copias

Cuando el tipo de elemento es un objeto, el array almacena referencias, no los objetos en sí:

String[] colors = {"red", "green", "blue"};
String first = colors[0];
// first and colors[0] both reference the same "red" string

Para los tipos primitivos esta distinción no importa — los valores int se copian al entrar y al salir. Para los objetos, mutar un elemento desde fuera del array muta lo que el array ve, porque comparten la referencia.

Valores predeterminados y arrays null

Una variable de array declarada pero no asignada es null, y leer .length o cualquier índice sobre ella lanza NullPointerException:

int[] data;            // not initialized
// System.out.println(data.length);  // would throw NullPointerException
data = new int[3];
System.out.println(data.length);     // 3

Un array vacío — de longitud cero — es un array perfectamente válido, y normalmente es lo que quieres como valor de retorno "vacío", no null:

int[] none = new int[0];
System.out.println(none.length);     // 0

Un ejemplo completo

Imprimir un array

Una sorpresa frecuente: pasar un array directamente a System.out.println no muestra su contenido. En cambio, imprime el tipo del array y su hash de identidad:

int[] scores = {90, 85, 73};
System.out.println(scores);   // e.g. [I@39ed3c8d  — not the values!

El [I significa "array de int" y la parte hexadecimal es un hash de identidad, no los datos. Para ver los elementos, usa Arrays.toString del paquete java.util:

import java.util.Arrays;

int[] scores = {90, 85, 73};
System.out.println(Arrays.toString(scores));   // [90, 85, 73]

Para arrays anidados (multidimensionales), usa Arrays.deepToString en su lugar.

¿Qué sigue?

Ya puedes construir un array y acceder a sus elementos por índice. El siguiente paso es la iteración — visitar cada elemento en orden con bucles sobre arrays, para no tener que escribir scores[0], scores[1], scores[2] uno por uno.

Práctica