Arreglos en Java

Un arreglo en Java es un contenedor de tamaño fijo que guarda una secuencia de valores del mismo tipo. Una vez que lo crea, su longitud nunca cambia, y cada casilla puede almacenar exactamente un valor — un int, un String, una referencia a cualquier objeto, todo lo que encaje en el tipo declarado.

Los arreglos son la base sobre la que están construidas el resto de las colecciones de Java (ArrayList, HashMap y compañía). No son tan ergonómicos como esas clases de más alto nivel, pero son rápidos, predecibles, y los verá por todas partes — argumentos de método, valores de retorno, código sensible al rendimiento.

Declarar un arreglo

El tipo de un arreglo 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ía usar.

Declarar una variable aún no crea un arreglo; solo le da a Java una casilla que puede contener una referencia a uno. La casilla empieza como null.

Crear un arreglo con new

Para asignar realmente el arreglo, use new con una longitud:

int[] scores = new int[5];

Esto reserva espacio para 5 int. Java inicializa cada casilla con el valor por defecto del tipo:

• tipos numéricos → 0 (o 0.0)
• boolean → false
• char → ' '
• tipos de referencia → null

Así que scores contiene de inmediato {0, 0, 0, 0, 0}. No existe un estado «sin inicializar» — una vez creado el arreglo, cada posición tiene un valor definido.

Literales de arreglo

Cuando conoce el contenido de antemano, use un literal:

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

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

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

Acceder a los elementos

Lee y escribe los elementos por í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 por defecto ni da la vuelta.

La propiedad length

Cada arreglo tiene un campo length público y de solo lectura que indica su tamaño:

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

Observe que es un campo, no un método — sin paréntesis. Esta es una de las pequeñas rarezas de Java: las cadenas usan .length(), los arreglos usan .length. También se comportan distinto de las colecciones (list.size()). Las formas son fáciles de confundir; el compilador se lo dirá.

length queda fijada en la creación. Para «hacer crecer» un arreglo debe asignar uno nuevo y copiar — vea el capítulo Copiar arreglos.

Los arreglos guardan referencias, no copias

Cuando el tipo de elemento es un objeto, el arreglo 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 primitivos esta distinción no importa — los valores int se copian al entrar y salir. Para los objetos, mutar un elemento desde fuera del arreglo muta lo que el arreglo ve, porque comparten la referencia.

Valores por defecto y arreglos null

Una variable de arreglo declarada pero no asignada vale 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 arreglo vacío — de longitud cero — es un arreglo perfectamente válido, y suele ser lo que quiere para un valor de retorno «vacío», no null:

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

Un ejemplo resuelto

Qué sigue

Sabe construir un arreglo y acceder a él por índice. El siguiente paso es la iteración — visitar cada elemento por turno con los bucles sobre arreglos, para no tener que escribir scores[0], scores[1], scores[2] uno por uno.

Practice