Un array multidimensional es un array cuyos elementos son, a su vez, otros arrays.
En el artículo anterior aprendimos a gestionar listas de datos con arrays unidimensionales. Algunas estructuras necesitan representar filas, columnas o más dimensiones.
A veces necesitamos representar una tabla de Excel, un tablero de ajedrez, los píxeles de una imagen o un mapa de coordenadas (x, y).
Para estos casos, Java nos permite subir de dimensión. Bienvenidos a los Arrays Multidimensionales.
¿Qué es realmente una matriz en Java?
Antes de ver el código, hay que entender la arquitectura.
Si vienes de C o C++, quizás pienses que una matriz 3x3 es un bloque de memoria contiguo de 9 huecos. En Java NO es así.
En Java, estrictamente hablando, no existen los arrays multidimensionales. Lo que existe son Arrays de Arrays.
- Tienes un Array “maestro” (las filas).
- Cada hueco de ese array maestro contiene una referencia a otro array diferente (las columnas).
Este detalle permite crear filas de distintos tamaños, conocidas como jagged arrays, como veremos luego.
Matrices
Son los más comunes. Se definen con doble corchete [][]. El primer corchete representa las filas y el segundo las columnas.
Declaración e inicialización
// Opción A: Reservando espacio (Matriz vacía)
// Creamos una tabla de 3 filas y 4 columnas
int[][] matriz = new int[3][4];
// Opción B: Con valores iniciales (Visualmente es una tabla)
int[][] tablero = {
{1, 2, 3}, // Fila 0
{4, 5, 6}, // Fila 1
{7, 8, 9} // Fila 2
};Acceso a datos
Para acceder, usamos coordenadas [fila][columna]. Recuerda que empezamos en 0.
System.out.println(tablero[0][0]); // Imprime 1 (Esquina superior izquierda)
System.out.println(tablero[1][2]); // Imprime 6 (Fila 1, Columna 2)Recorriendo una matriz
Para visitar todas las celdas, necesitamos bucles anidados. Un bucle se encarga de bajar por las filas, y el otro de recorrer las columnas de esa fila.
int[][] matriz = {
{10, 20, 30},
{40, 50, 60}
};
// Bucle externo: Recorre las FILAS
for (int i = 0; i < matriz.length; i++) {
// Bucle interno: Recorre las COLUMNAS de la fila 'i'
for (int j = 0; j < matriz[i].length; j++) {
System.out.print(matriz[i][j] + " ");
}
System.out.println(); // Salto de línea al acabar cada fila
}Fíjate en .length:
matriz.length: Nos da el número de filas (el tamaño del array maestro).matriz[i].length: Nos da el número de columnas de la fila actual.
Jagged arrays
Gracias a que Java implementa las matrices como “Arrays de Arrays”, no estamos obligados a que todas las filas tengan el mismo tamaño. Podemos crear estructuras triangulares o irregulares. Esto se conoce como Jagged Arrays (Arrays dentados).
Imagina un cine donde la fila 1 tiene 2 asientos, la fila 2 tiene 3 asientos y la fila 3 tiene 4.
// Paso 1: Definimos las filas, pero dejamos las columnas vacías
int[][] cine = new int[3][];
// Paso 2: Inicializamos cada fila individualmente
cine[0] = new int[2]; // Fila 0: 2 asientos
cine[1] = new int[3]; // Fila 1: 3 asientos
cine[2] = new int[4]; // Fila 2: 4 asientos
// Rellenamos un dato
cine[1][2] = 50; // Funciona
// cine[0][2] = 50; // ¡ERROR! La fila 0 solo tiene índices 0 y 1.Esto ahorra mucha memoria si tienes matrices dispersas (con muchos huecos vacíos), ya que solo reservas espacio para lo que usas.
Más dimensiones
Podemos seguir añadiendo corchetes hasta el infinito (bueno, hasta 255 dimensiones por especificación de la JVM, pero rara vez pasarás de 3).
Un array 3D int[][][] se suele visualizar como un cubo o un conjunto de páginas.
// Un cubo de 3x3x3 (Ej: Cubo de Rubik)
int[][][] cubo = new int[3][3][3];
cubo[0][1][2] = 5; // Cara 0, Fila 1, Columna 2