Arrays Multidimensionales en Java

Java no tiene en realidad un tipo "array 2D" separado. Lo que tiene son arrays de arrays: un int[][] es un array cuyos elementos son a su vez int[]. La sintaxis es suficientemente corta como para parecer una cuadrícula integrada, y la mayor parte del tiempo puedes usarlo así. Si eres nuevo en los conceptos básicos, empieza con arrays en Java; esta página los amplía dimensión a dimensión.

Esta página cubre la declaración y asignación de arrays 2D, la lectura y escritura de celdas, la obtención de los recuentos de filas y columnas, la iteración, los arrays irregulares (no rectangulares) y el caso poco frecuente de dimensiones superiores.

Declarar un array 2D

Añade otro par de corchetes al tipo:

int[][] grid;
String[][] board;

Asigna con dos tamaños — primero filas, luego columnas:

int[][] grid = new int[3][4];   // 3 rows, 4 columns, all zero

O usa un literal anidado:

int[][] grid = {
  {1, 2, 3, 4},
  {5, 6, 7, 8},
  {9, 10, 11, 12}
};

Las llaves externas contienen tres sub-arrays, cada uno de longitud 4.

Acceder a elementos

Dos índices: primero la fila, luego la columna.

int[][] grid = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
System.out.println(grid[0][0]);   // 1
System.out.println(grid[2][1]);   // 8
grid[1][1] = 50;                  // replace 5 with 50

grid[0] por sí solo es la primera fila — en sí misma un int[] de longitud 3. Esa es la clave que hay que interiorizar: indexar una vez te da una fila, indexar dos veces te da una celda.

length para filas y columnas

grid.length es el número de filas. grid[r].length es el número de columnas en la fila r:

int rows = grid.length;
int cols = grid[0].length;   // assuming row 0 exists

No existe un grid.cols de nivel superior porque Java no asume que todas las filas tengan la misma longitud — véanse los arrays irregulares a continuación.

Iterar

El doble for estándar:

for (int r = 0; r < grid.length; r++) {
  for (int c = 0; c < grid[r].length; c++) {
    System.out.print(grid[r][c] + " ");
  }
  System.out.println();
}

O con for mejorado, tratando cada fila como un int[]:

for (int[] row : grid) {
  for (int cell : row) {
    System.out.print(cell + " ");
  }
  System.out.println();
}

Usa la forma mejorada cuando no te importan las coordenadas, y la forma clásica cuando sí lo hacen.

Arrays irregulares

Los arrays internos no tienen que tener la misma longitud. Un array de arrays en Java puede ser irregular — con cada fila dimensionada de forma independiente:

int[][] triangle = new int[4][];   // 4 rows, columns unspecified
triangle[0] = new int[]{1};
triangle[1] = new int[]{1, 2};
triangle[2] = new int[]{1, 2, 3};
triangle[3] = new int[]{1, 2, 3, 4};

O con un literal:

int[][] triangle = {
  {1},
  {1, 2},
  {1, 2, 3},
  {1, 2, 3, 4}
};

La iteración funciona exactamente igual — preguntas a cada fila su propia .length:

for (int r = 0; r < triangle.length; r++) {
  for (int c = 0; c < triangle[r].length; c++) {
    System.out.print(triangle[r][c] + " ");
  }
  System.out.println();
}

Por eso int[][] es "array de arrays" en lugar de una verdadera matriz: nada en el lenguaje obliga a que todas las filas tengan la misma anchura.

Dimensiones superiores

El patrón se extiende. int[][][] es un array de arrays de arrays — útil para una cuadrícula 3D, una pila de matrices, una imagen RGB (alto × ancho × 3):

int[][][] cube = new int[2][3][4];   // 2 × 3 × 4
cube[0][1][2] = 99;

En la práctica, cualquier cosa más allá de 2D es poco frecuente en Java idiomático — en ese punto, una clase con campos con nombre es casi siempre más clara.

Un ejemplo práctico

Qué viene a continuación

Ya has visto arrays en una y más dimensiones. A continuación veremos las operaciones con arrays del día a día — obtener la longitud, rellenar, buscar, copiar — y los ayudantes de la biblioteca estándar que convierten la mayoría de ellas en una sola línea.

Práctica