Inicializando una matriz multidimensional en Java

¿Cuál es la forma correcta de declarar una matriz multidimensional y asignarle valores?

Esto es lo que tengo:

int x = 5;
int y = 5;

String[][] myStringArray = new String [x][y];

myStringArray[0][x] = "a string";
myStringArray[0][y] = "another string";

Intente reemplazar las líneas apropiadas con:

myStringArray[0][x-1] = "a string";
myStringArray[0][y-1] = "another string";

Su código es incorrecto porque las submatrices tienen una longitud de y, y la indexación comienza en 0. Por lo tanto, la configuración en myStringArray[0][y]o myStringArray[0][x]fallará porque los índices xy yestán fuera de los límites.

String[][] myStringArray = new String [x][y];es la forma correcta de inicializar una matriz multidimensional rectangular. Si desea que sea irregular (cada submatriz tiene potencialmente una longitud diferente), puede usar un código similar a esta respuesta . Sin embargo, tenga en cuenta que la afirmación de John de que debe crear las submatrices manualmente es incorrecta en el caso de que desee una matriz multidimensional perfectamente rectangular.

Java no tiene matrices multidimensionales "verdaderas".

Por ejemplo, arr[i][j][k]es equivalente a ((arr[i])[j])[k]. En otras palabras, arres simplemente una matriz, de matrices, de matrices .

Entonces, si sabe cómo funcionan las matrices, ¡sabe cómo funcionan las matrices multidimensionales!

Declaración:

int[][][] threeDimArr = new int[4][5][6];

o, con inicialización:

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

Acceso:

int x = threeDimArr[1][0][1];

o

int[][] row = threeDimArr[1];

Representación de cadena:

Arrays.deepToString(threeDimArr);

rendimientos

"[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]"

Articulos útiles

• Java: inicialización de una matriz multidimensional
• Java: matrices y matrices multidimensionales

También puede utilizar la siguiente construcción:

String[][] myStringArray = new String [][] { { "X0", "Y0"},
                                             { "X1", "Y1"},
                                             { "X2", "Y2"},
                                             { "X3", "Y3"},
                                             { "X4", "Y4"} };

Puede declarar matrices multidimensionales como:

// 4 x 5 String arrays, all Strings are null
// [0] -> [null,null,null,null,null]
// [1] -> [null,null,null,null,null]
// [2] -> [null,null,null,null,null]
// [3] -> [null,null,null,null,null]

String[][] sa1 = new String[4][5];
for(int i = 0; i < sa1.length; i++) {           // sa1.length == 4
    for (int j = 0; j < sa1[i].length; j++) {     //sa1[i].length == 5
        sa1[i][j] = "new String value";
    }
}


// 5 x 0  All String arrays are null
// [null]
// [null]
// [null]
// [null]
// [null]
String[][] sa2 = new String[5][];
for(int i = 0; i < sa2.length; i++) {
    String[] anon = new String[ /* your number here */];
    // or String[] anon = new String[]{"I'm", "a", "new", "array"};
    sa2[i] = anon;
}

// [0] -> ["I'm","in","the", "0th", "array"]
// [1] -> ["I'm", "in", "another"]
String[][] sa3 = new String[][]{ {"I'm","in","the", "0th", "array"},{"I'm", "in", "another"}};

Matriz multidimensional en Java

Devolviendo una matriz multidimensional

Java no verdaderamente admite matrices multidimensionales. En Java, una matriz bidimensional es simplemente una matriz de matrices, una matriz tridimensional es una matriz de matrices de matrices, una matriz de cuatro dimensiones es una matriz de matrices de matrices de matrices, y así sucesivamente ...

Podemos definir una matriz bidimensional como:

1. int[ ] num[ ] = {{1,2}, {1,2}, {1,2}, {1,2}}

2. int[ ][ ] num = new int[4][2]

   num[0][0] = 1;
   num[0][1] = 2;
   num[1][0] = 1;
   num[1][1] = 2;
   num[2][0] = 1;
   num[2][1] = 2;
   num[3][0] = 1;
   num[3][1] = 2;
   

   Si no asigna, digamos num[2][1], no se inicializa y luego se asigna automáticamente 0, es decir, automáticamente num[2][1] = 0;

3. A continuación, num1.lengthle da filas.

4. Mientras num1[0].lengthte da la cantidad de elementos relacionados con num1[0]. Aquí num1[0]tiene matrices relacionadas num1[0][0]y num[0][1]solo.

5. Aquí usamos un forbucle que nos ayuda a calcular num1[i].length. Aquí ise incrementa a través de un bucle.

   class array
   {
       static int[][] add(int[][] num1,int[][] num2)
       {
           int[][] temp = new int[num1.length][num1[0].length];
           for(int i = 0; i<temp.length; i++)
           {
               for(int j = 0; j<temp[i].length; j++)
               {
                   temp[i][j] = num1[i][j]+num2[i][j];
               }
           }
           return temp;
       }
   
       public static void main(String args[])
       {
           /* We can define a two-dimensional array as
                1.  int[] num[] = {{1,2},{1,2},{1,2},{1,2}}
                2.  int[][] num = new int[4][2]
                    num[0][0] = 1;
                    num[0][1] = 2;
                    num[1][0] = 1;
                    num[1][1] = 2;
                    num[2][0] = 1;
                    num[2][1] = 2;
                    num[3][0] = 1;
                    num[3][1] = 2;
   
                    If you don't allocate let's say num[2][1] is
                    not initialized, and then it is automatically
                    allocated 0, that is, automatically num[2][1] = 0;
                 3. Below num1.length gives you rows
                 4. While num1[0].length gives you number of elements
                    related to num1[0]. Here num1[0] has related arrays
                    num1[0][0] and num[0][1] only.
                 5. Here we used a 'for' loop which helps us to calculate
                    num1[i].length, and here i is incremented through a loop.
           */
           int num1[][] = {{1,2},{1,2},{1,2},{1,2}};
           int num2[][] = {{1,2},{1,2},{1,2},{1,2}};
   
           int num3[][] = add(num1,num2);
           for(int i = 0; i<num1.length; i++)
           {
               for(int j = 0; j<num1[j].length; j++)
                   System.out.println("num3[" + i + "][" + j + "]=" + num3[i][j]);
           }
       }
   }
   

Agregaré que si desea leer las dimensiones, puede hacer esto:

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

System.out.println(a.length);  // 4
System.out.println(a[0].length); // 3
System.out.println(a[0][0].length); //2

También puede tener matrices dentadas , donde diferentes filas tienen diferentes longitudes, entonces a[0].length != a[1].length.

 int[][] myNums = { {1, 2, 3, 4, 5, 6, 7}, {5, 6, 7, 8, 9, 10, 11} };
 for (int x = 0; x < myNums.length; ++x) {
    for(int y = 0; y < myNums[i].length; ++y) {
       System.out.print(myNums[x][y]);
    }
 }

Salida

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

Puedes mirar esto para empezar:

    int [][][] i = {                //third dimension curly brace
                     {               // second dimension curly brace
                        {            //first dimension curly brace
                           1,1,1    //elements
                        },           
                    {3,3,3},    
                    {2,2,2}     
                      },
                      {
                         {
                          1,1,1
                         },
                         {3,3,3},
                         {2,2,2}
                       }
                    };