Introducción a los arrays

1. Un array es un contenedor de elementos

Probablemente hayas oído que los ordenadores pueden procesar enormes volúmenes de información. El operador condicional (if-else) y los bucles (for, while) ayudan, por supuesto. Pero no basta con eso: los datos que procesamos hay que almacenarlos de algún modo.

Para ello, en Java, como en prácticamente todos los lenguajes de programación, existe una cosa estupenda: los arrays (Array). También se les llama tablas.

Un array es un objeto especial en el que se puede almacenar no un único valor, sino varios.

Si antes comparábamos una variable con una caja (donde podemos guardar algún valor), entonces un array es más bien una caja dividida en secciones. Cada sección de la «caja‑array» tiene su número. La numeración, por supuesto, empieza en cero…

O podemos hacer otra analogía. Compare una casa unifamiliar con un edificio de pisos. Una casa unifamiliar la ocupa una familia, mientras que un edificio está dividido en pisos/apartamentos. Para enviar una carta a una familia que vive en una casa normal, hay que indicar su dirección única. Y para enviar una carta a una familia que vive en un piso, hay que indicar la dirección única del edificio y además el número del piso.

Así que, una variable‑array es como un edificio de pisos. En ella puedes almacenar no un solo valor, sino varios. En esa variable hay varios pisos (celdas), y a cada uno puedes acceder por su número (índice).

Para ello, después del nombre de la variable, entre corchetes, hay que indicar el índice de la celda a la que accedemos. Es bastante sencillo:

array[indeks] = znachenie;

Donde array es el nombre de la variable‑array, indeks es el número de la celda en el array, y znachenie es el valor que queremos guardar en la celda indicada.

Pero antes, veamos cómo crear arrays.

2. Creación de un array de elementos en Java

Supongamos que tu programa necesita almacenar 100 números enteros. Lo más probable es que para esto sirva un array. ¿Y cómo se crea?

Si quisiéramos almacenar un solo número entero, usaríamos el tipo int; y si queremos almacenar 100 números enteros, probablemente necesitemos un array de tipo int. Así sería el código para crearlo:

int[] array = new int[100];

Analicemos qué pone aquí.

Como ya habrás adivinado, a la izquierda del signo igual tenemos la declaración de una variable llamada array y de tipo int[]. Tras el tipo int van los corchetes, que sugieren que en las «cajas» de este tipo se podrán guardar no un único valor, sino varios.

A la derecha del signo igual tenemos la «creación de un objeto» (la palabra new) con 100 elementos (celdas) de tipo int. Tampoco es muy complicado.

Si, por ejemplo, quisiéramos crear un array de 20 celdas para almacenar números de coma flotante, el código sería aproximadamente así:

double[] vals = new double[20];

Al número de celdas de un array se le llama tamaño del array o longitud del array. Y por su capacidad de almacenar muchos valores, a los arrays también se les llama contenedores.

Dato importante: el tamaño del contenedor‑array no se puede cambiar después de su creación.

Se puede crear uno nuevo, pero no es posible cambiar la longitud de un contenedor ya creado.

3. Trabajo con las celdas del array

Bien, ya sabemos crear arrays, ¿y cómo trabajar correctamente con ellos?

Casi igual que con variables normales, solo que después del nombre de la variable‑array hay que indicar obligatoriamente el número de la celda con la que trabajamos.

La numeración de las celdas de un array siempre empieza en cero. Si tenemos un array de 10 elementos, entonces los números (índices) de sus celdas son 0..9; si el array es de 200 elementos, entonces 0..199. Y así sucesivamente.

Ejemplos:

int[] a = new int[10];	// Creamos un array de 10 elementos de tipo int.

a[2] = 4;				// En la celda con índice 2 guardamos el valor 4.

a[7] = 9;				// En la celda con índice 7 guardamos el valor 9.

a[9] = a[2] + a[5];		// En la celda con índice 9 guardamos la suma de los valores que hay en las celdas 2 	
                        // (hay 4) y 5 (hay 0). 

Esto es lo que habrá en memoria tras ejecutar el código anterior:

La columna a la izquierda del array (en gris) son los números (índices) de las celdas. En las celdas se almacenan los valores introducidos: 4, 9 y 4. Justo después de crear un array, sus celdas están rellenas con ceros.

Importante. Todas las celdas de un array tienen el mismo tipo de datos. Si hemos creado un array de cadenas String, en sus celdas solo se pueden almacenar cadenas. El tipo de datos del array se fija al crearlo. Ni el tipo de datos ni la longitud del array se pueden cambiar más adelante.

4. Arrays en memoria

Las imágenes de los ejemplos anteriores son un poco inexactas.

Al crear arrays (igual que al crear cadenas) se reservan dos bloques de memoria: uno para almacenar el propio array (el contenedor) y otro para la variable que almacena su dirección. La situación precisa se muestra en la imagen de abajo:

En verde se muestra un array de 10 elementos de tipo int y una variable de tipo int[] que guarda la dirección (referencia) del array de tipo int en memoria.

Para comparar, en azul se indica una variable normal de tipo int, que almacena el valor 199.

Recuerda al almacenamiento de cadenas en memoria, ¿no te parece?

Exacto, las cadenas. Y como al trabajar con cadenas, las «variables de tipo array» se pueden asignar entre sí:

int[] a = new int[10];		// Creamos un array de 10 elementos de tipo int.

a[2] = 4;					// En la celda con índice 2 guardamos el valor 4.
a[7] = 9;					// En la celda con índice 7 guardamos el valor 9.

int[] b = a;				// En la variable b guardamos la dirección que hay en la variable a.
                            // Ahora a y b apuntan al mismo objeto‑array en memoria.

a[9] = b[2] + a[7];			// En la celda con índice 9 del objeto‑array guardamos la suma de los valores 
                            // que hay en las celdas 2 (hay 4) y 7 (hay 9). 

El objeto‑array seguirá donde estaba, y las variables a y b almacenarán direcciones (referencias) iguales al mismo objeto. Mira la imagen:

5. Trabajo con arrays con más detalle

Se puede crear un array de absolutamente cualquier tipo. Solo hay que escribir corchetes después del nombre del tipo. La forma general de creación de un array es la siguiente:

tip[] imya = new tip[kolichestvo];

Donde tip es el tipo de los elementos (celdas) del array que vamos a almacenar en él. Imya es el nombre de la variable con el que accederemos al array, y kolichestvo es el número de celdas del array.

En el ejemplo anterior se muestra la forma canónica: creación de la variable‑array y creación del objeto‑array. En realidad son dos construcciones independientes. Se pueden crear la variable‑array y el objeto‑array por separado:

tip[] imya;
imya = new tip[kolichestvo];

Y otro punto no menos importante

Tanto el índice del array como la cantidad de elementos del array pueden ser variables e incluso expresiones completas.

Ejemplos:

int n = 100;
int[] a = new int[n];			// 	Creamos un array de n elementos

int n = 100;
int[] a = new int[n * 2 + 3];	// 	Creamos un array de 203 elementos

int n = 100;
int[] a = new int[n];
a[n-1] = 2;					// a[99] = 2;
a[n-2] = 3;					// a[98] = 3;
a[n/5] = a[n-1] + a[n-2]	// a[20] = a[99] + a[98];

Salir de los límites del array

Por cierto, ten en cuenta que si intentas acceder a una celda del array con un índice que el array no tiene (en nuestro caso, cualquier número entero excepto los números 0..99), el programa terminará abruptamente con el error ArrayIndexOutOfBoundsException — índice fuera de los límites del array.

6. Longitud del array

Como vimos en el ejemplo anterior, se puede crear por separado una variable de tipo array y luego, en algún punto del código, asignarle un valor (una referencia a un objeto‑array). Incluso se puede hacer así:

int[] array;			//	Creamos una variable‑array de tipo int[]
if (a < 10)				// Si la variable a es menor que 10,
   array = new int[10];	// entonces crear un array de 10 elementos.
else					// En caso contrario
   array = new int[20];	// crear un array de 20 elementos 

¿Y cómo trabajar después con ese array? ¿Cómo saber cuántos elementos tiene?

Para ello, el array tiene una propiedad especial (variable) — length. Y se puede conocer la longitud del array con la siguiente expresión:

array.length;

Donde array es el nombre de la variable‑array, y length es el nombre de la propiedad del objeto‑array. El valor de la propiedad length no se puede cambiar: se puede asignar la propiedad length a otras variables, pero a ella no se le puede asignar nada (el programa simplemente no compilará).

Así podemos continuar el ejemplo anterior:

int[] array;			//	Creamos una variable‑array de tipo int[]
if (a < 10)				// Si la variable a es menor que 10,
   array = new int[10];	// entonces crear un array de 10 elementos.
else					// En caso contrario
   array = new int[20];	// crear un array de 20 elementos 

for (int i = 0; i < array.length; i++)	// Bucle por todos los elementos del array: de 0 hasta array.length - 1
{
   System.out.println(array[i]);
}

7. Hechos sobre los arrays en Java

Resumamos los hechos conocidos sobre los arrays:

• Hecho 1. Un array consta de múltiples celdas.
• Hecho 2. El acceso a una celda concreta se realiza indicando su número.
• Hecho 3. Todas las celdas son del mismo tipo.
• Hecho 4. El valor inicial de todas las celdas es 0 y null (si en la celda se almacena una dirección), false (para el tipo boolean).
• Hecho 5. String[] list es solo la declaración de una variable: el contenedor (el objeto‑array) aún no se ha creado. Para poder trabajar con él, hay que crear el array (contenedor) y guardarlo en esa variable, y solo entonces usarlo. Ver ejemplo abajo.
• Hecho 6. Cuando creamos un objeto‑array (contenedor), hay que indicar su longitud — cuántas celdas tiene. Esto se hace con un comando del tipo: new TypeName[n];
• Hecho 7. La longitud del array se puede conocer a través de la propiedad .length.
• Hecho 8. Después de crear un array no se puede cambiar ni el tipo de sus elementos ni su cantidad.

String s;				// s es igual a null
String[] list;			// list es igual a null

list = new String[10];	// La variable list guarda una referencia a un objeto: un array de cadenas de 10 elementos.
int n = list.length;	// n es igual a 10

list = new String[0];	// Ahora list contiene un array de 0 elementos. 
                        // El array existe, pero no puede almacenar elementos.

list = null;
System.out.println(list[1]); // Se generará un error — el programa terminará abruptamente. 
                            // list contiene una referencia vacía — null

list = new String[10];
System.out.println(list[10]);	// Se generará un error — fuera de los límites del array.
//	Si list contiene 10 elementos/celdas, los índices permitidos son: 0 1 2 3 4 5 6 7 8 9 — en total 10.