Anteriormente he hablado sobre lo que es un Arreglo Unidimensional y tambien lo que es un Arreglo de Objetos, pero seguramente has escuchado de los Arreglos Bidimensionales ó Multidimensionales en Java. Para tener una idea clara de esto lo haremos primero con lo que se sabe de momento, armar un arreglo bidimensional con arreglos unidimensionales. Supongamos que necesitamos una tabla en la cual mostremos tres ciudades de cuatro paises:

Para lo anterior tendriamos que usar 4 Arreglos, uno para los paises, y los demas para las ciudades de cada pais, ademas tendriamos que tener especial cuidado al momento de relacionarlos, para tal ejercicio tendremos el siguiente codigo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

import javax.swing.JOptionPane;
 
public class Cuento {
 
    /*lo que se pretende mostrar
 
    *   Argentina   Buenos aires      cordoba       La plata
    *   Colombia    Bogota            Cali          Medellin
    *   Chile       Concepción        Santiago      Valparaiso
    *   Mexico      Ciudad Juárez     León          Monterrey 
    */
 
public static void main(String args []) {
 
    String paises []= {"Agentina","Colombia","Chile", "Mexico"},     
           CiudadAr[]={"Buenos Aires", "Cordoba", "La Plata"},
           CiudadCo[]={"Bogota", "Cali", "Medellin"},
           CiudadCh[]={"Concepción", "Santiago", "Valparaiso"},
           CiudadMx[]={"Ciudad Juárez", "León", "Monterrey"};
 
    String ax="";
 
 
    for(int i=0; i<paises.length; i++){
        ax+="n"+paises[i]+"        ";
        for(int j=0; j<3; j++){
            switch(i){
                case 0:
                    ax+="   "+CiudadAr[j]+"   ";
                break;
                case 1:
                    ax+="       "+CiudadCo[j]+"     ";
                break;
                case 2:
                    ax+="   "+CiudadCh[j]+"       ";
                break;
                case 3:
                    ax+="   "+CiudadMx[j]+"       ";
                break;
            }
        }
    }
 
    JOptionPane.showMessageDialog(null, ax);
 
}
}

Cuando lo ejecutemos veremos lo siguiente:

Si, sé que no esta bien ordenado graficamente 🙁 esto se arreglara con mas variables y mas codigo para obtener algo visualmente mas llamativo, pero como es netamente un ejemplo no le he dedicado mas a esto 😉 Analizando el anterior ejemplo encontramos:

CARACTERISTICAS DE UN ARREGLO MULTIDIMENSIONAL

1. Tienen filas y columnas, por lo tanto cuenta con dos indices. Generalmente se maneja el concepto de [Fila][Columna], aunque podria ser tambien [Columna][Fila].
2. La relacion entre valores se da por los indices.
3. Los arreglo unidimensionales se ordenan en fila, en cambio los multidimensionales se pueden acomodar en columnas dadas por lo indices.
4. En el anterior ejemplo usamos 5 arreglos que muestra una tabla o una matriz de 4×4, con los arreglos multidimensionales podriamos usar 1 solo arreglo del mismo tamaño (4×4).
5. El recorrido de filas y columnas se hace por medio de ciclos, esta a nuestra eleccion el primer recorrido que deseemos hacer, podriamos recorrer primero la columna que la fila, o recorrer desde determinado indice [i][j].

La creacion de un arreglo multidimensional tiene la siguiente estructura:

1

tipo nombrearreglo [][] = new tipo[#Filas][#Columnas];

Teniendo en cuenta que el tipo puede ser int, Float, Double, String, o hasta una clase abstracta. Sabiendo esto, aplicaremos el concepto de arreglo multidimensional al anterior ejemplo de los paises:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

import javax.swing.JOptionPane;
 
public class Cuento {
 
    /*lo que se pretende mostrar
 
    *   Argentina   Buenos aires      cordoba       La plata
    *   Colombia    Bogota            Cali          Medellin
    *   Chile       Concepción        Santiago      Valparaiso
    *   Mexico      Ciudad Juárez     León          Monterrey 
    */
 
public static void main(String args []) {
 
    String [][] arrMulti ={  {"Agentina","Buenos Aires", "Cordoba", "La Plata"},
                             {"Colombia","Bogota", "Cali", "Medellin"},
                             {"Chile","Concepción", "Santiago", "Valparaiso"},
                             {"Mexico","Ciudad Juárez", "León", "Monterrey"},                             
                          };
 
    String ax="";
 
    for(int i=0; i<4; i++){
        for(int j=0; j<4; j++){
           ax+= arrMulti[i][j]+"        ";
        }
        ax+="n";
    }
 
    JOptionPane.showMessageDialog(null, ax);
 
}
}

Si comparas el codigo del primer ejemplo con el del segundo ejemplo podras ver que el segundo ya esta ordenado como una tabla, mostrando directamente la relacion entre fila, columna; y no usando un switch para saber que ciudades pertenecen a determinado pais. Algo para tener en cuenta, que asi mismo como se muestra se obtiene, en otras palabras, en lugar de almacenar un valor a mostrar podriamos ingresar datos en el espacio de la siguiente forma:

1
2
3
4
5
6

for(int i=0; i<4; i++){
        for(int j=0; j<4; j++){
           arrMulti[i][j] = JOptionPane.showInputDialog("Ingresa el dato: ");
        }
        ax+="n";
    }

Si te ha gustado el post, compártelo, regala un like ó comenta 😉