Enter the Matrix

La dimensión desconocida ...

Después del asunto de trabajar con arreglos y pensando un poco en el asunto de la dimensión de una variable, retomo el hecho de que las variables podrían eventualmente tener más de una dimensión , en este caso la idea de arreglo se generaliza de manera libre.

¿Pensaron alguna vez en la idea de hacer un arreglo de arreglos?

¿Qué tal un arreglo de arreglos de arreglos?

Si la pregunta es si se puede, en la mayoría de lenguajes de programación SE PUEDE!. El asunto es que al tratar de modelar esta estructura inevitablemente estamos ampliando las dimensiones de una variable. Si una variable entera (solita, como la traje yo al mundo) tiene dimensión cero y un arreglo tiene dimensión 1 (el espacio donde se mueven sus posiciones), una matriz podría considerarse como una variable que tiene dimensión superior a 1, por ejemplo 2 (Lo que implica dos indices de posición o coordenadas)

         0       1      2       3       4

     +------++------++------++------++------+
  0  |  ' ' ||  ' ' ||  ' ' ||  ' ' ||  ' ' |
     |      ||      ||      ||      ||      |
     +------++------++------++------++------+
     +------++------++------++------++------+
  1  |  ' ' ||  ' ' ||  ' ' ||  ' ' ||  ' ' |
     |      ||      ||      ||      ||      |
     +------++------++------++------++------+
     +------++------++------++------++------+
  2  |  ' ' ||  'O' ||  'S' ||  'O' ||  ' ' |
     |      ||      ||      ||      ||      |
     +------++------++------++------++------+
     +------++------++------++------++------+
  3  |  ' ' ||  ' ' ||  ' ' ||  ' ' ||  ' ' |
     |      ||      ||      ||      ||      |
     +------++------++------++------++------+

Extiende la declaración!

La idea inicial que habíamos usado previamente para asuntos dimensionales tenía que ver con el uso del operador [] que nos permitía acceder a posiciones cualquiera de un conjunto en una dimensión (arreglo). La idea cuando aparecen multiples dimensiones es exactamente la misma, pero requiere del uso de más operadores [] para identificar las demás coordenadas. En el caso de dos dimensiones, se requiere uno para trabajar las filas y uno para trabajar las columnas donde se ubica un elemento dentro del conjunto. El anterior ejemplo hace una matriz bidimensional de caracteres, cualquier parecido con la conformación de una sopa de letras o un Scrabble es pura coincidencia...:)

Por extensión, la sintaxis para declarar una matriz tiene la misma estructura que la que usa un arreglo.

char [] arregloLetras = new char[10];
char [][] matrizLetras = new char[15][15];

char [][][] cuboLetras = new char[10][10][10];

En la primera linea se declaro un conjunto de caracteres de tamaño 10, en el segundo ejemplo se declara una matriz de caracteres de tamaño 15X15.  char[][] actua como el tipo (matriz de caracteres), matrizLetras es el nombre de la variable y new char[15][15] crea las variables necesarias para hacer la matriz con 15 X 15 variables de tipo char. Esto se podría interpretar tambien como declarar un arreglo de tamaño 15 donde cada posición es un arreglo de tamaño 15 de caracteres, por eso el uso de dos operadores [] seguidos. El último ejemplo declara una matriz de caracteres de tamaño 10X10X10 (tres dimensiones).

En ese orden de ideas, char es la palabra que designa el tipo "caracter", char[] designa el tipo "conjunto de caracteres" y char[][] designa el tipo "matriz de caracteres" o "conjunto de conjuntos" de caracteres. El ultimo ejemplo se podría comprender como una extensión de lo anterior, osea char[][][] sería una "matriz tridimensional de caracteres" o un "conjunto de conjuntos de conjuntos de caracteres".

Asignación y consulta

La asignación y consulta de una matriz requiere el uso del operador [] así como pasa en los arreglos, pero al tratarse de un conjunto de dos dimensiones, se requiere de su uso 2 veces. De esta manera, las instrucciones: 

matrizLetras[0][0]='x';
matrizLetras[1][5]='y';
matrizLetras[2][3]='z';

Modifican posiciones específicas de la matriz, la primera línea modifica la posición <0,0> de la matriz y asigna el valor 'x'. Los indices de la matriz (valores que se ponen dentro del operador []) se consideran como filas(para el primer indice) y columnas (para el segundo), así en la segunda instrucción se cambia la posición fila = 1, columna = 5 asignando el valor 'y'. En la tercera instrucción se modifica la posición <2,3> de la matriz y se asigna el valor 'z'.

Así mismo, se puede consultar un valor de una matriz mediante el operador []. Para imprimir un valor de la matriz basta con usarlo de igual forma:

System.out.println(matrizLetras[0][0]);
System.out.println(matrizLetras[1][5]);
System.out.println(matrizLetras[2][3]);

De esta manera, estas tres líneas imprimirán en la pantalla los valores 'x', 'y' y 'z' de acuerdo con lo anterior.

Ciclos y matrices - Recorridos

Los indices de una matriz evidentemente son números enteros, por ende se podrían poner dentro del operador [] valores variables. Uno de los usos más importantes tiene que ver con el recorrido de matrices. El recorrido de matrices se suele utilizar cuando hay que pasar por todas las posiciones de una matriz para hacer algo específico. 

 
for(int i=0; i<matrizLetras.length; i++)  
 {  
      for(int j=0; j<matrizLetras[i].length; j++)  
      {  
           matrizLetras[i][j]= '_';  
      }  
 }  

En este ejemplo, hemos usado un primer ciclo que recorra todas las filas de la matriz. Nótese que llamado length tiene ese propósito. En el segundo ciclo, se utiliza el operador length pero para cada posición i de la matriz (según el razonamiento, usar el operador [] una sola vez en una matriz bidimensional, nos entregaría un arreglo y a ese arreglo es al que le estamos pidiendo el tamaño). En resumen, el primer ciclo funciona tantas veces como filas tenga la matríz y cada una de esas veces un segundo ciclo funciona tantas veces como columnas tenga la matriz. Así, en este ejemplo se recorren 15 filas y por cada una de ellas se recorren 15 columnas, osea que la instrucción matrizLetras[i][j] sucederá 15X15 veces (225).

En el anterior ejemplo se asigna el caracter '_' a todas las posiciones de la matriz sin excepción. Si se quisieran hacer recorridos parciales se podría jugar con el ciclo para que no toda posición fuera tenida en cuenta. Para ello se pueden variar los inicios del ciclo o su condición. Un ejemplo de ello es recorrer solo una fila de la matriz, para ello se hace un ciclo solo para las columnas y se deja constante la fila:

      int filaconstante=2;  
      for(int j=0; j<matrizLetras[filaconstante].length; j++)  
      {  
           matrizLetras[filaconstante][j]= 'x';  
      }  
      int columnaconstante=2;  
      for(int i=0; i<matrizLetras[columnaconstante].length; i++)  
      {  
           matrizLetras[i][columnaconstante]= 'y';  
      }  
      for(int i=0; i<matrizLetras[columnaconstante].length; i++)  
      {  
           matrizLetras[i][i]= 'd';  
      }  

En el segundo ciclo se recorre solo una columna y el ciclo varía las filas. En el tercer ciclo se recorre la diagonal de la matriz, osea las posiciones <0,0>, <1,1>.... etc.