Syntax zum Erstellen eines zweidimensionalen Arrays

Erwägen:

int[][] multD = new int[5][];
multD[0] = new int[10];

Erstellen Sie auf diese Weise ein zweidimensionales Array mit 5 Zeilen und 10 Spalten?

Ich habe diesen Code online gesehen, aber die Syntax ergab keinen Sinn.

Versuche Folgendes:

int[][] multi = new int[5][10];

... was für so etwas eine kurze Hand ist:

int[][] multi = new int[5][];
multi[0] = new int[10];
multi[1] = new int[10];
multi[2] = new int[10];
multi[3] = new int[10];
multi[4] = new int[10];

Beachten Sie, dass jedes Element wird auf den Standardwert initialisiert werden int, 0so die oben auch gleichwertig sind:

int[][] multi = new int[][]{
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

Wir können ein zweidimensionales Array deklarieren und Elemente zum Zeitpunkt seiner Deklaration direkt speichern als:

int marks[][]={{50,60,55,67,70},{62,65,70,70,81},{72,66,77,80,69}};

Hier steht int für Elemente vom Typ Integer, die im Array gespeichert sind, und der Array-Name lautet 'Markierungen'. int ist der Datentyp für alle Elemente, die in den Klammern "{" und "}" dargestellt werden, da ein Array eine Sammlung von Elementen mit demselben Datentyp ist.

Zurück zu unserer obigen Aussage: Jede Reihe von Elementen sollte in geschweiften Klammern stehen. Die Zeilen und Elemente in jeder Zeile sollten durch Kommas getrennt werden.

Beachten Sie nun die Aussage: Sie können 3 Zeilen und 5 Spalten erhalten, sodass die JVM 3 * 5 = 15 Speicherblöcke erstellt. Diese Blöcke können einzeln bezeichnet werden als:

marks[0][0]  marks[0][1]  marks[0][2]  marks[0][3]  marks[0][4]
marks[1][0]  marks[1][1]  marks[1][2]  marks[1][3]  marks[1][4]
marks[2][0]  marks[2][1]  marks[2][2]  marks[2][3]  marks[2][4]

HINWEIS:
Wenn Sie n Elemente speichern möchten, beginnt der Array-Index bei Null und endet bei n-1 . Eine andere Möglichkeit, ein zweidimensionales Array zu erstellen, besteht darin, das Array zuerst zu deklarieren und dann mithilfe eines neuen Operators Speicher zuzuweisen.

int marks[][];           // declare marks array
marks = new int[3][5];   // allocate memory for storing 15 elements

Durch die Kombination der beiden oben genannten können wir schreiben:

int marks[][] = new int[3][5];

Sie können sie genau so erstellen, wie andere es erwähnt haben. Noch ein Punkt, den Sie hinzufügen sollten: Sie können sogar mit jeder Zeile ein verzerrtes zweidimensionales Array erstellen, das nicht unbedingt die gleiche Anzahl von Spalten aufweist, wie folgt:

int array[][] = new int[3][];
array[0] = new int[3];
array[1] = new int[2];
array[2] = new int[5];

Die gebräuchlichste Redewendung zum Erstellen eines zweidimensionalen Arrays mit 5 Zeilen und 10 Spalten lautet:

int[][] multD = new int[5][10];

_{Alternativ können Sie Folgendes verwenden, das dem, was Sie haben, ähnlicher ist, obwohl Sie jede Zeile explizit initialisieren müssen:}

int[][] multD = new int[5][];
for (int i = 0; i < 5; i++) {
  multD[i] = new int[10];
}

Es ist auch möglich, es folgendermaßen zu deklarieren. Es ist kein gutes Design, aber es funktioniert.

int[] twoDimIntArray[] = new int[5][10];

Versuchen:

int[][] multD = new int[5][10];

Beachten Sie, dass in Ihrem Code nur die erste Zeile des 2D-Arrays auf 0 initialisiert wird. Die Zeilen 2 bis 5 sind nicht einmal vorhanden. Wenn Sie versuchen, sie zu drucken, erhalten Sie nullfür jeden von ihnen.

int [][] twoDim = new int [5][5];

int a = (twoDim.length);//5
int b = (twoDim[0].length);//5

for(int i = 0; i < a; i++){ // 1 2 3 4 5
    for(int j = 0; j <b; j++) { // 1 2 3 4 5
        int x = (i+1)*(j+1);
        twoDim[i][j] = x;
        if (x<10) {
            System.out.print(" " + x + " ");
        } else {
            System.out.print(x + " ");
        }
    }//end of for J
    System.out.println();
}//end of for i

In Java kann ein zweidimensionales Array als dasselbe wie ein eindimensionales Array deklariert werden. In einem eindimensionalen Array können Sie wie schreiben

  int array[] = new int[5];

Dabei ist int ein Datentyp, array [] eine Array-Deklaration und new arrayein Array mit seinen Objekten mit fünf Indizes.

Auf diese Weise können Sie ein zweidimensionales Array wie folgt schreiben.

  int array[][];
  array = new int[3][4];

Hier arrayist ein int-Datentyp. Ich habe zuerst ein eindimensionales Array dieses Typs deklariert, dann wird ein 3-Zeilen- und 4-Spalten-Array erstellt.

In deinem Code

int[][] multD = new int[5][];
multD[0] = new int[10];

bedeutet, dass Sie ein zweidimensionales Array mit fünf Zeilen erstellt haben. In der ersten Zeile befinden sich 10 Spalten. In Java können Sie die Spaltengröße für jede Zeile nach Ihren Wünschen auswählen.

int rows = 5;
int cols = 10;

int[] multD = new int[rows * cols];

for (int r = 0; r < rows; r++)
{
  for (int c = 0; c < cols; c++)
  {
     int index = r * cols + c;
     multD[index] = index * 2;
  }
}

Genießen!

Versuchen Sie Folgendes:

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

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

Diese Arten von Arrays werden in Java als gezackte Arrays bezeichnet:

int[][] multD = new int[3][];
multD[0] = new int[3];
multD[1] = new int[2];
multD[2] = new int[5];

In diesem Szenario enthält jede Zeile des Arrays die unterschiedliche Anzahl von Spalten. Im obigen Beispiel enthält die erste Zeile drei Spalten, die zweite Zeile zwei Spalten und die dritte Zeile fünf Spalten. Sie können dieses Array zur Kompilierungszeit wie folgt initialisieren:

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

Sie können alle Elemente in Ihrem Array einfach iterieren:

for (int i = 0; i<multD.length; i++) {
    for (int j = 0; j<multD[i].length; j++) {
        System.out.print(multD[i][j] + "\t");
    }
    System.out.println();
}

Tatsächlich hat Java kein mehrdimensionales Array im mathematischen Sinne. Was Java hat, ist nur ein Array von Arrays, ein Array, in dem jedes Element auch ein Array ist. Aus diesem Grund ist die Größe der ersten Dimension die absolute Voraussetzung für die Initialisierung. Wenn der Rest angegeben ist, wird ein Array mit dem Standardwert erstellt.

int[][]   ar  = new int[2][];
int[][][] ar  = new int[2][][];
int[][]   ar  = new int[2][2]; // 2x2 array with zeros

Es gibt uns auch eine Eigenart. Die Größe des Unterarrays kann nicht durch Hinzufügen weiterer Elemente geändert werden. Wir können dies jedoch tun, indem wir ein neues Array mit beliebiger Größe zuweisen.

int[][]   ar  = new int[2][2];
ar[1][3] = 10; // index out of bound
ar[1]    = new int[] {1,2,3,4,5,6}; // works