A veces necesitamos varias variables que desempeñan el mismo papel, y podemos utilizar nombres iguales con un número que las diferencia, por ejemplo coordenadas de dibujo de distintas formas:   x1,y1 - x2,y2 - x3,y3 ...
Se puede hacer de este modo cuando son pocas, pero para grandes cantidades utilizamos matrices (arrays). Podemos pensar en una  matriz como un mueble con muchos cajones numerados. De este modo podemos acceder al valor guardado en cada cajón utilizando el número que lo identifica, su índice.
Definimos las matrices de forma semejante a las variables, pero tenemos que indicar la cantidad de elementos que pueden contener:

int[] x= new int[3];   // creamos una matriz de 3 elementos (del 0 al 2)
x[0] = 90;    // asigna un valor al primer elemento del array
x[1] = 120;    // asigna un valor al primer elemento del array
x[2] = 150;    // asigna un valor al primer elemento del array

ahora podemos usar esos valores para dibujar:

ellipse ( x[0] , 50 , 20 , 20 ) ;
ellipse ( x[1] , 50 , 20 , 20 ) ; // . . .

Existe una forma alternativa de definir la matriz, directamente asignando los valores
int[] numbers = { 90, 150, 30 }; //


Accediendo a los elementos con una variable

Podemos indicar el elemento de la matriz mediante una variable, en vez de con un número. De este modo podemos recorrer todos los valores de la matriz en un bucle. Podemos usar este truco para rellenar todos los elementos de una matriz, y para acceder a cada uno de ellos cuando tenemos que utilizarlos para realizar cálculos o para dibujar formas.

int[] x = new int[100];
  for (int i=0 ;  i < 100 ;  i++) {
  x[i] = int ( random(6) + 1 ) ;
}

Para evitar errores, es conveniente utilizar una variable que contenga el número de elementos de la matriz. De este modo no tenemos que modificar el código en diversos lugares si queremos cambiar el número de elementos.

int  numX = 100 ;  //  número de elementos de la matriz x[]
int[] x = new int [ numX ];
for (int i=0 ;  i < numX ;  i++) {
  x[i] = int ( random(6) + 1 ) ;
}


Añadir y quitar elementos

Es conveniente calcular el número de elementos que vamos a utilizar previamente, y definir la matriz con su tamaño adecuado desde el principio. A veces es necesario añadir elementos mientras funciona el programa. No es fácil ni cómodo de realizar en Processing (debido al diseño de JAVA). Podemos crear una copia de la matriz en una nueva, añadiendo un nuevo elemento, pero no es práctico:

int[] x2 = append ( x, 180 ) ; 

y del mismo modo podemos eliminarlo un valor copiando la matriz a otra:

int[] x2 =  shorten( x ) ;


Sí es posible aumentar el tamaño de una matriz en una cantidad de elementos con:

expand( x , newSize ) ;


Existen otras estructuras de datos  más complejas que provienen de JAVA como ArrayList, HashMap, IntDic. Pueden ser adecuadas para proyectos complejos, pero no son recomendables en la iniciación a Processing.



Controlando el número de elementos

Aumentar o disminuir el tamaño de una matriz tiene un fuerte impacto en la velocidad de ejecución del código: el programa tiene que pararse y dedicar un tiempo a reorganizar las zonas de memoria que utiliza para almacenar los datos. Para evitar esta parada, que puede resulta molesta visualmente, podemos usar un truco: 
Creamos una matriz más grande de lo necesario inicialmente, contando con el número máximo de elementos posibles. Con una variable controlamos el número de elementos que estamos utilizando en cada momento, y podemos añadir y quitar elementos, siempre controlando que no superen el máximo admitido. De este modo nos aseguramos además de que los elementos no crezcan de forma desmesurada, llegando a colapsar el programa.
La gestión de este tipo de matrices puede requerir de bloques especiales de código que reubiquen los datos, los ordenen, etc.

int[] x = new int [ 1000 ] ;  // el máximo de elementos posibles será 1000 (de 0 a 999)
int  numX = 2 ;  //  número de elementos inicial de la matriz x[]

x[0] = int ( random(6) + 1 ) ;
x[1] = int ( random(6) + 1 ) ;

// añadimos un elemento incrementando la variable de control
if (numX <1000) { // comprobamos que no hemos llegado al máximo
  numX ++ ; // cada vez que añadimos un elemento
  x[numX]  = int ( random(6) + 1 ) ; // le asignamos un valor
}

Para borrar un elemento sería necesario reducir la variable de control, y recolocar todos los datos.


Matrices de dos dimensiones

En programación gráfica resulta muy útil el manejo de matrices de dos dimensiones. Nos permiten acceder a una rejilla bidimensional con valores almacenados. La pantalla del ordenador, por ejemplo, es una de estas matrices bidimensionales, o muchos juegos de mesa de tablero como el ajedrez.
El manejo es muy semejante al de las matrices de una dimensión:

int [ ][ ] pos = new int[4][4];
pos[2][2]=999;
println (pos[0][0]);
print (pos[2][2]);


Matrices multidimensionales

Es posible utilizar matrices de 3 o más dimensiones. Simplemente añadimos los corchetes necesarios:

int [ ][ ][ ] pos = new int[8][8][8];

El manejo puede resultar confuso, y en muchas ocasiones preferimos utilizar varias matrices, una para cada dimensión:

x[ ] - y[ ] - z[ ] ...