MAD07 - InfoVis & GenerArt

Almacenamiento: arrays

Otra forma de almacenamiento del ordenador son los arrays. Los arrays son zonas de memoria que almacenan un número determinado de variables del mismo tipo de forma contigua. Así podemos crear arrays de ints, arrays de floats o arrays de Strings. Esto nos permitirá trabajar con un gran número de variables sin tener que definirlas una por una. En esta sesión veremos como crear y usar arrays.

Los arrays se declaran mediante el nombre del tipo de variables que albergarán seguidos de dos corchetes y después el nombre de nuestro array. e.g. int[] miArray;

Los arrays se definen de forma similar pero escribiendo new antes y determinado la longitud del array entre los corchetes e.g. miArray = new int[10];

Para acceder a cualquiera de las variables de un array llamaremos el nombre del array seguido de los corchetes con el indice de la variable en medio. Hay que recordar que los indices de un array empiezan en 0. e.g. miArray[0] = 1;

Leer una casilla de un array con un indice superior de lo posible nos lanzará un error de tipo java.lang.ArrayIndexOutOfBoundsException. Este es un error muy común cuando se trabaja con arrays. e.g. print(miArray[10]); nos lanzaría este error, porque miArray tiene solo 10 casillas y el elemento con indice 10 sería el onceavo puesto que los indices comienzan en 0.

Una acción muy común sobre los arrays es inicializarlos con una serie de valores, hay varias formas de hacerlo, las dos más comunes suelen ser:

• A la mano mediante una lista constante. e.g. int[] miArray = {0,1,2,3,4,5,6};
• Mediante un bucle for. e.g.

1
2
3
4

int[] miArray = new int[10];
for(int i=0;i<miarray.length;i++){
    miArray[i] = 26;
}

Hay que tener en cuenta que una variable sin inicializar tiene un valor igual a null. Y es muy común tener que probar si un array es igual a null antes de acceder a él e incluso antes de llamar a su variable miembro length.

Processing tiene unas cuantas funciones que ayudan el uso de arrays. Una de las funciones es int[] append(int[] miArray, int value) la cual nos permite que le añadamos un valor a un array. Otra vez no se puede llamar append sobre un array igual a null. En estos casos habra que crear un array de talla 1 con el valor que queramos añadir en la casilla 0.

1
2

int[] miArray;
miArray = append(miArray, 26);

Dará un error, y para evitarlo habrá que hacer:

1
2
3
4
5
6
7

int[] miArray;
if(miArray == null){
  miArray = new int[1];
  miArray[0] = 26;
}else{
  miArray = append(miArray, 26);
}

Finalmente en muchos casos se quiere acceder secuencialmente y repetidamente a los valores de un array, en estos casos lo mas sencillo suele ser usar una variable que nos servirá de indice, y cada vez que accedemos a un valor incrementaremos de uno el indice. Sin embargo si hiciésemos esto continuamente nos saldríamos del array, así que usaremos la función modulo (%) para que no sobrepase la longitud de este. e.g.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

int[] miArray = new int[10];
int miIndice = 0;
 
void setup(){
  for(int i = 0; i<miarray.length;i++){
    miArray[i] = i;
  }
}
 
void draw(){
  // En este caso no seria realmente necesario comprobar si es null
  // pero es buena practica
  if(miArray != null){
    print(miArray[miIndice]);
    miIndice = (miIndice + 1) % miArray.length;
  }
}