Arreglos...¿Y eso que?

El asunto de arreglos siempre ha generado expectativa entre mis estudiantes debido a que este tema suele recordarles que ciertos conceptos sobre uso y declaración de variables no están tan claros como creen. En realidad los arreglos no dejan de ser más que un tipo de variable con la particularidad que permite representar conjuntos de tamaño definido.

Inicios, comparando con lo que ya sabemos

Un día vimos como de la nada se podía crear una variable y darle un valor. Esa declaración de variable requiere inicialmente de un tipo (p.e int, double, char, String, Scanner, etc) y de un nombre para la recién bautizada variable. Eso equivale a separar un espacio en la memoria del computador para almacenar un valor y etiquetarlo con un nombre.

int variable = 5; 


  +-------+
  |       |
  |  5    |
  |       |
  `.......'
   miVariable

En la anterior instrucción especificamos un tipo (int, osea entero) , un nombre para la variable (miVariable) y un valor inicial (5). En el caso de los arreglos no es demasiado diferente.

int[] conjuntoEntero = new int[9];
conjuntoEntero[0]=3;
conjuntoEntero[1]=1;
...
conjuntoEntero[8]=20;


    +-----+-----+-----+------+-----+----+----+-----+-------+
    |  3  |  1  | 15  |  11  | 10  | -1 |  2 |  4  |  -20  |
    |     |     |     |      |     |    |    |     |       |
    +-----+-----+-----+------+-----+----+----+-----+-------+
       0     1     2      3     4    5    6     7      8

Aquí también especificamos un tipo (int[], osea arreglo de enteros), un nombre para la variable (conjuntoEntero) y un valor inicial (evidentemente toca posición por posición). Lo primero que notamos es que no podemos intervenir sobre todo el conjunto al mismo tiempo, se hace posición por posición. Para este propósito se usa el operador [] que nos permite acceder a una posición dentro del arreglo. En este caso se puede hacer lo mismo que con una variable.

conjuntoEntero // es una variable de tipo "arreglo de enteros"
conjuntoEntero[0] // es una variable de tipo "entero"

Ciclos y arreglos...recorriendo un conjunto

Un arreglo tiene un tamaño en principio definido, pero no necesariamente lo conocemos. Una de las cosas típicas que se hace con un arreglo es recorrerlo con diferentes propósitos, por ejemplo sumar sus elementos.

Así se realizaría dicho procedimiento:

int suma = 0;
for ( int i = 0; i< conjuntoEntero.length; i++)
{
 suma = suma + conjuntoEntero[i];
}

La variable suma almacena entonces un cero inicialmente y será incrementada dependiendo del valor de cada posición del arreglo. El ciclo funcionaría entonces desde i =0 hasta el tamaño del arreglo (nótese el llamado a  length que me da su tamaño) y tomaría "el i-ésimo" valor del arreglo y lo suma en la variable suma (valga la redundancia). El índice que estoy aplicando en el arreglo es el mismo valor que uso en el ciclo!!

Conclusiones varias

Los arreglos son tipos de variables también, dicho de una manera matemática los tipos que habíamos usado antes son variables de dimensión cero (int, char, String, etc.), los arreglos son tipos de variables de dimensión 1 (int[], char[], String[]) y evidentemente existen tipos de variables de dimensiones superiores a 1 (matrices). La idea detrás de un arreglo es representar un conjunto de datos de tamaño fijo y eso es lo que se especifica en su declaración.

Cada elemento de un arreglo es del tipo que se declaró previamente. Si el conjunto es de enteros, uno de sus elementos es entero (¿Obvio no?). El operador de indirección ([]) se utiliza para referirse a uno de los elementos. Para hacer operaciones con todo el conjunto se suele usar un ciclo.