Initialisieren eines mehrdimensionalen Arrays in Java

Was ist der richtige Weg, um ein mehrdimensionales Array zu deklarieren und ihm Werte zuzuweisen?

Das habe ich:

int x = 5;
int y = 5;

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

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

Versuchen Sie, die entsprechenden Zeilen durch Folgendes zu ersetzen:

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

Ihr Code ist falsch, da die Sub-Arrays eine Länge von yhaben und die Indizierung bei 0 beginnt. Die Einstellung auf myStringArray[0][y]oder myStringArray[0][x]wird daher fehlschlagen, weil die Indizes xund yaußerhalb der Grenzen liegen.

String[][] myStringArray = new String [x][y];ist der richtige Weg, um ein rechteckiges mehrdimensionales Array zu initialisieren. Wenn Sie möchten, dass es gezackt ist (jedes Sub-Array hat möglicherweise eine andere Länge), können Sie Code verwenden, der dieser Antwort ähnlich ist . Beachten Sie jedoch, dass Johns Behauptung, dass Sie die Unterarrays manuell erstellen müssen, falsch ist, wenn Sie ein perfekt rechteckiges mehrdimensionales Array wünschen.

Java hat keine "echten" mehrdimensionalen Arrays.

Zum Beispiel arr[i][j][k]ist äquivalent zu ((arr[i])[j])[k]. Mit anderen Worten, arrist einfach ein Array, von Arrays, von Arrays .

Wenn Sie also wissen, wie Arrays funktionieren, wissen Sie, wie mehrdimensionale Arrays funktionieren!

Erklärung:

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

oder mit Initialisierung:

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

Zugriff:

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

oder

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

Zeichenfolgendarstellung:

Arrays.deepToString(threeDimArr);

ergibt

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

Nützliche Artikel

• Java: Initialisieren eines mehrdimensionalen Arrays
• Java: Matrizen und mehrdimensionale Arrays

Sie können auch das folgende Konstrukt verwenden:

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

Sie können mehrdimensionale Arrays wie folgt deklarieren:

// 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"}};

Mehrdimensionales Array in Java

Rückgabe eines mehrdimensionalen Arrays

Java unterstützt mehrdimensionale Arrays nicht wirklich . In Java ist ein zweidimensionales Array einfach ein Array von Arrays, ein dreidimensionales Array ist ein Array von Arrays von Arrays, ein vierdimensionales Array ist ein Array von Arrays von Arrays von Arrays und so weiter ...

Wir können ein zweidimensionales Array definieren als:

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;

   Wenn Sie nicht zuweisen, num[2][1]wird es beispielsweise nicht initialisiert und dann automatisch 0 zugewiesen, dh automatisch num[2][1] = 0.

3. Unten finden num1.lengthSie Zeilen.

4. Während num1[0].lengthgibt Ihnen die Anzahl der Elemente in Bezug auf num1[0]. Hier num1[0]hat verwandte Arrays num1[0][0]und num[0][1]nur.

5. Hier haben wir eine forSchleife verwendet, die uns bei der Berechnung hilft num1[i].length. Hier iwird durch eine Schleife inkrementiert.

   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]);
           }
       }
   }

Ich füge hinzu, dass Sie Folgendes tun können, wenn Sie die Abmessungen lesen möchten:

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

Sie können auch gezackte Arrays haben , bei denen verschiedene Zeilen unterschiedliche Längen haben 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]);
    }
 }

Ausgabe

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

Sie können dies betrachten, um zu beginnen:

    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}
                       }
                    };