Arrays de 3 dimensiones

Un array tridimensional es un array de arrays de arrays. Si un array 2D (bidimensional) se puede imaginar como una tabla (filas × columnas), un array 3D se puede visualizar como un conjunto de tablas apiladas, añadiendo una tercera dimensión que habitualmente llamamos profundidad (o capa/bloque).

         Capa 0              Capa 1
    [ 1,  2,  3 ]       [ 10, 20, 30 ]
    [ 4,  5,  6 ]       [ 40, 50, 60 ]
    [ 7,  8,  9 ]       [ 70, 80, 90 ]

Cada elemento se identifica con tres índices: [capa][fila][columna].

Casos de uso habituales

• Representar imágenes en color: cada píxel tiene tres valores (R, G, B) → imagen[fila][columna][canal].
• Modelar datos temporales 2D: datos organizados por tiempo, fila y columna → datos[tiempo][fila][columna].
• Representar estructuras 3D en simulaciones físicas (temperatura en un sólido, fluidos, etc.).

Declaración

// Sintaxis general
tipoDato[][][] nombreArray;

// Ejemplos
int[][][] cubo;
double[][][] espacio;

Creación (inicialización)

Con new

La creación con new establece un tamaño fijo del array.

int[][][] cubo = new int[2][3][4];
// 2 capas, 3 filas por capa, 4 columnas por fila
// Todos los valores se inicializan a 0

Valores por defecto

Cuando se crea una array con new, todas las posiciones toman el valor por defecto del tipo de dato del array.

Con valores literales

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

Acceso a elementos

int[][][] cubo = {
    {{1, 2}, {3, 4}},
    {{5, 6}, {7, 8}}
};

System.out.println(cubo[0][0][0]); // 1  → capa 0, fila 0, columna 0
System.out.println(cubo[0][1][1]); // 4  → capa 0, fila 1, columna 1
System.out.println(cubo[1][0][1]); // 6  → capa 1, fila 0, columna 1
System.out.println(cubo[1][1][1]); // 8  → capa 1, fila 1, columna 1

// Modificar un valor
cubo[1][0][0] = 99;

Recorrer un array tridimensional

Se necesitan tres bucles for anidados: el más externo itera sobre las capas, el intermedio sobre las filas y el más interno sobre las columnas.

Con for clásico

int[][][] cubo = new int[2][3][4];

// Rellenar con valores de ejemplo
int valor = 1;
for (int k = 0; k < cubo.length; k++) {
    for (int i = 0; i < cubo[k].length; i++) {
        for (int j = 0; j < cubo[k][i].length; j++) {
            cubo[k][i][j] = valor++;
        }
    }
}

// Mostrar el contenido
for (int k = 0; k < cubo.length; k++) {
    System.out.println("--- Capa " + k + " ---");
    for (int i = 0; i < cubo[k].length; i++) {
        for (int j = 0; j < cubo[k][i].length; j++) {
            System.out.printf("%4d", cubo[k][i][j]);
        }
        System.out.println();
    }
}

Salida:

--- Capa 0 ---
   1   2   3   4
   5   6   7   8
   9  10  11  12
--- Capa 1 ---
  13  14  15  16
  17  18  19  20
  21  22  23  24

Con for-each

for (int[][] capa : cubo) {
    for (int[] fila : capa) {
        for (int valor : fila) {
            System.out.print(valor + "\t");
        }
        System.out.println();
    }
    System.out.println("---");
}

Propiedades útiles

int[][][] cubo = new int[2][3][4];

int numCapas    = cubo.length;         // 2
int numFilas    = cubo[0].length;      // 3
int numColumnas = cubo[0][0].length;   // 4

Ejemplo completo

Una imagen en color se puede representar como un array tridimensional donde cada píxel tiene tres componentes:

• R (rojo)
• G (verde)
• B (azul)

Los valores oscilan entre 0 y 255.

public class ImagenRGB {
    public static void main(String[] args) {
        // imagen[fila][columna][canal]  → canal: 0=R, 1=G, 2=B
        int[][][] imagen = new int[2][3][3];

        // Píxel rojo en [0][0]
        imagen[0][0][0] = 255; // R
        imagen[0][0][1] = 0;   // G
        imagen[0][0][2] = 0;   // B

        // Píxel verde en [0][1]
        imagen[0][1][0] = 0;
        imagen[0][1][1] = 255;
        imagen[0][1][2] = 0;

        // Mostrar el valor del canal Rojo del primer píxel
        System.out.println("Canal R del píxel [0][0]: " + imagen[0][0][0]); // 255
    }
}