En la pasada entrega vimos las variables, que son muy importantes a la hora de programar nuestros proyectos. Ahora, aumentaremos un poco el nivel de dificultad, describiendo el uso de unas estructuras llamadas arrays, que nos permitirán guardar varios valores en una sola variable.

¿Que es un array?

Podemos definir un array como una estructura que nos permite almacenar un conjunto de datos (básicamente serían como una variable, con múltiples valores independientes, pero del mismo tipo).

Los arrays tienen tamaño definido (lo veremos más adelante), y pueden ser de varias dimensiones (1, 2, 3...). Con tamaño, nos referimos al número de datos que se pueden almacenar en nuestro array.
Sobre las dimensiones, imaginemos un array unidimensional como una fila de puntos. Cada punto es un dato.
Ahora, imaginemos un array bidimensional como una tabla. Cada celda de nuestra tabla es un dato.
De qué forma podríamos ver un array de 3 dimensiones? Correcto, como un cubo.

Así podríamos seguir aumentando las dimensiones del array. Por supuesto, no es práctico trabajar con arrays de más de 3 dimensiones, sobre todo porque ya no tienen una representación geométrica. Por lo general, sólo usaremos arrays de 1 y 2 dimensiones (llamados vectores y matrices, respectivamente).

Accediendo a sus valores.

Todos los datos de un array tienen una dirección única, que llamaremos índice. En el caso de vectores, podemos imaginar el índice como un número que nos indica la posición de nuestro dato (como si estuviera en una fila).
En las matrices, tendremos dos índices, que podemos compararlos con coordenadas en dos ejes, como si de un plano coordenado se tratara. Así, a cada dato de nuestra matriz le correspondería un par de índices, indicando la fila y la columna en que se encuentra.

Nota: En cualquier caso, el valor de los índices inicia en 0 (cero).

*Representación gráfica de un vector de 10 elementos, y una matriz de 3x10 elementos.

Trabajando con Arrays

Hasta aquí es suficiente de teoría, empecemos con el código xD.
Primero que nada, veremos cómo definir un array:

//Para un array unidimensional (un vector)
     Tipo_de_dato Nombre_Array[];
 
          Nombre_Array = new Tipo_de_dato[tamaño];
 
//o bien, para un array bidimensional (una matriz)
     Tipo_de_dato Nombre_Array[][];
 
          Nombre_Array = new Tipo_de_dato[tamañoX][tamañoY];
 
// También podemos usar para una dimensión...
     Tipo_de_dato Nombre_Array[] = new Tipo_de_dato[tamaño];
 
//o para dos dimensiones...
     Tipo_de_dato Nombre_Array[][] = new Tipo_de_dato[tamañoX][tamañoY];

Donde:

• Tipo_de_dato. Es el tipo de dato que almacenaremos en nuestro array. Se manejan los mismos tipos de datos ya vistos en la entrega de Variables, por lo que no profundizaré más al respecto. Hay que tomar en cuenta que una vez definido, no podremos cambiar el tipo de datos de nuestro array, ni tampoco mezclar tipos de datos en un mismo array.
• Nombre_Array. Es el nombre que asignaremos a nuestro array, como si de una variable se tratara.
• Variables tamaño. Se trata de enteros, que nos indican el tamaño de nuestro array, o lo que es lo mismo, el número de espacios que tendrá el array (o la cantidad de espacio que reservará en memoria). Éstos son los índices en el caso de matrices, el primer argumento indica el número de filas que tendrá nuestra matriz.
  Un punto a destacar, es que el tamaño de un array no se puede cambiar una vez definido.

Nota: Seamos prácticos, no vale la pena declarar un array de 50 espacios, si sólo usaremos 10 (o declarar una matriz y usar sólo una de sus filas o columnas).

Ahora pasaremos a ejemplificar el uso arrays.
Para asignar valores a nuestros arrays, procederemos de la misma manera que con las variables, pero indicando un índice (o índices, dependiendo de las dimensiones de nuestro array). El índice determinará el espacio que ocupará el valor que estamos ingresando, recordando que siempre se inicia en 0. Esto quiere decir que si declaramos un array de 5 espacios, el índice irá desde 0 hasta 4.
Prediquemos con el ejemplo:

// Primero defino e inicializo mi array:
     int Numero[] = new int[5];
 
// Ahora, introduciré unos valores. 
// CUIDADO, los índices de un array se inicializan en 0 !!!
 
     Numero[0] = 45;
     Numero[1] = 90;
     Numero[2] = 3030;
     Numero[3] = 60;
     Numero[4] = 75755;
 
 
// Que ahora nos apetece un array bidimensional con decimales? Vamos a ello:
     float Decimal[][] = new float[2][2];
 
     Decimal[0][0] = 1.5;
     Decimal[0][1] = 8.5;
     Decimal[1][0] = 4.33;
     Decimal[1][1] = 5.245;

Con los valores de nuestros arrays podemos usar cualquiera de los operadores que ya vimos en una entrega pasada.
Veamos unos ejemplos:

// Una suma
     resultados[0] = sumandos[0] + sumandos[1];
 
//Una operación múltiple
     resultados[1] = (( operandos[5] + operandos[3]) * 25 ) / ( operandos[2]+8); 
 
//Usando un valor en una condición
     if (resultados[1] >= 56);    //A saber si se cumplirá xD 
 
//Asigno el valor de una posición a otra
     resultados[3] = resultados[2];

El uso de arrays puede ser algo confuso al principio, pero una vez que le cogemos el truco resulta útil si tenemos variables del mismo tipo y relacionadas entre sí. Todo es cuestión de paciencia, práctica e imaginación.

Por ahora eso es todo, hasta la próxima entrega ;)