Arrays bidimensionales

1. Introducción

Imagina un array normal como una caja larga de pizza, donde todas las porciones están en fila: delicioso, pero monótono.

Ahora pensemos en un horario de trabajo o en un tablero de ajedrez. Ahí ya todo está organizado en filas y columnas, es decir, en una tabla. Eso es precisamente un caso clásico para un array bidimensional.

En la vida real, los arrays bidimensionales aparecen en todas partes:

• Tablas con salarios de empleados (filas — empleados, columnas — meses).
• Una imagen en pantalla (cada «celda» es el color de un píxel y tiene dos coordenadas: X e Y).
• Cálculo matricial y procesamiento de datos.
• Un tablero de ajedrez o un campo de tres en raya.

A veces a un array bidimensional se le llama matriz (el nombre viene de las matemáticas).

Hay muchos casos en los que, como programador, puedes necesitar un array bidimensional. La implementación de casi cualquier juego de mesa es un array bidimensional ya preparado: «Ajedrez», «Damas», «Tres en raya», «Batalla naval»:

El campo de juego de «Ajedrez» o «Batalla naval» encaja perfectamente con arrays bidimensionales, donde para las coordenadas de las celdas solo necesitas usar números. No «peón e2 ⟶ e4», sino «peón (4,1) ⟶ (4,3)». Como programador, te resultará incluso más sencillo.

2. Sintaxis de declaración de arrays bidimensionales

Solo asusta hasta la primera declaración. Lo vemos paso a paso.

Regla general

tip[][] imyaMassiva;

Aquí dos corchetes vacíos [] no son un error del compilador tras una noche con café, sino una indicación: el array es bidimensional.

Ejemplos

int[][] matrix;
double[][] gradesTable;
string[][] chessBoard;

Creación de un array

Indicamos las dimensiones: número de filas y número de columnas.

matrix = new int[3][4]; // 3 filas, 4 columnas

Es una tabla 3x4: imagina una tabla de Excel con 3 filas y 4 columnas.

También se puede declarar la variable y crear el array bidimensional a la vez:

int[][] matrix = new int[3][4];

Se puede inicializar directamente con valores (de forma similar a unidimensionales):

int[][] example = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
// Tabla de 3 filas y 3 columnas

Esquema visual

┌─────┬─────┬─────┬─────┐
│  0  │  1  │  2  │  3  │  ← columnas (Columnas)
├─────┼─────┼─────┼─────┤
│ 0,0 │ 0,1 │ 0,2 │ 0,3 │  ← fila 0 (Row 0)
├─────┼─────┼─────┼─────┤
│ 1,0 │ 1,1 │ 1,2 │ 1,3 │  ← fila 1 (Row 1)
├─────┼─────┼─────┼─────┤
│ 2,0 │ 2,1 │ 2,2 │ 2,3 │  ← fila 2 (Row 2)
└─────┴─────┴─────┴─────┘

Cada elemento se define por un par de índices [fila, columna].

3. Indexación y acceso a los elementos

En un array bidimensional, para acceder a un elemento se especifican dos índices:

• El primero: el número de fila.
• El segundo: el número de columna.

      // En la segunda fila (índice 1), tercera columna (índice 2)
      matrix[1][2] = 99;

Si estás acostumbrado al ajedrez, recuerda: la indexación empieza en cero. Es decir, el primer elemento es [0][0].

Escritura y lectura

int[][] data = new int[5][2];
data[1][1] = 5;         // escritura
int value = data[1][1]; // lectura

Así es como se verá en memoria:

4. Rellenado de un array bidimensional

Escribamos un código que rellene la matriz con números consecutivos del 1 al 12, para que quede claro cómo funciona.

int[][] matrix = new int[3][4];
int value = 1;

for (int row = 0; row < 3; row++)
{
    for (int col = 0; col < 4; col++)
    {
        matrix[row][col] = value;
        value++;
    }
}

Ilustración:

Después de la ejecución:
┌────┬────┬────┬────┐
│ 1  │ 2  │ 3  │ 4  │
├────┼────┼────┼────┤
│ 5  │ 6  │ 7  │ 8  │
├────┼────┼────┼────┤
│ 9  │ 10 │ 11 │ 12 │
└────┴────┴────┴────┘

5. Estructura de los arrays bidimensionales

Ahora vas a descubrir cómo están organizados realmente los arrays bidimensionales. ¿Listos?

¡Los arrays bidimensionales son en realidad arrays de arrays!

En otras palabras, si en el caso de un array normal «la variable-array almacena una referencia a un contenedor que guarda los elementos del array», en el caso de los arrays bidimensionales la situación es un poco más explosiva: la variable-array-bidimensional guarda una referencia a un contenedor que almacena referencias a arrays unidimensionales. Es mejor verlo una vez que intentar explicarlo cien veces:

A la izquierda tenemos la «variable-array-bidimensional», que almacena una referencia al «objeto-array bidimensional». En el centro está el «objeto array bidimensional», en cuyas celdas se guardan referencias a arrays unidimensionales, es decir, a las filas del array bidimensional. Y a la derecha puedes ver cuatro arrays unidimensionales, las filas de nuestro array bidimensional.

Así es como están organizados realmente los arrays bidimensionales. Este enfoque ofrece al programador Java varias ventajas:

En primer lugar, ya que el «contenedor de contenedores» guarda referencias a «arrays-fila», podemos intercambiar filas de forma muy rápida y sencilla. Para acceder al «contenedor de contenedores» basta con indicar un índice en lugar de dos. Ejemplo:

int[][] data = new int[2][5];
int[] row1 = data[0];
int[] row2 = data[1];

Con un código como este podemos intercambiar filas:

// Matriz importante con datos
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {5, 4, 3, 2, 1}
};

int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;

Si accedes a una celda de un array bidimensional, pero después del nombre del array indicas solo un índice, estarás accediendo al contenedor de contenedores, en cuyas celdas se guardan referencias a arrays unidimensionales normales.

6. Imprimir un array bidimensional en pantalla

Para imprimir una tabla bidimensional suele utilizarse un bucle doble — es como dibujar un laberinto en la consola. Ejemplo:

for (int row = 0; row < matrix.length; row++) 
{
    for (int col = 0; col < matrix[row].length; col++) 
    {
        System.out.print(matrix[row][col] + "\t"); 
    }
    System.out.println(); // salto de línea
}

Ejemplo de salida:

1	2	3	4	
5	6	7	8	
9	10	11	12	

Por cierto, aquí has aprendido a «dibujar» tablas con un par de líneas de código.