Syntaxis voor het maken van een tweedimensionale array in Java

Overweeg:

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

Is dit hoe je een tweedimensionale array maakt met 5 rijen en 10 kolommen?

Ik zag deze code online, maar de syntaxis klopte niet.

Antwoord 1, autoriteit 100%

Probeer het volgende:

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

… wat een korte hand is voor zoiets als dit:

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

Houd er rekening mee dat elk element wordt geïnitialiseerd naar de standaardwaarde voor int, 0, dus het bovenstaande is ook gelijk aan:

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

Antwoord 2, autoriteit 10%

We kunnen een tweedimensionale array declareren en elementen direct opslaan op het moment van declaratie als:

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

Hier staat intvoor elementen van het type integer die in de array zijn opgeslagen en de arraynaam is ‘marks’. intis het gegevenstype voor alle elementen die worden weergegeven binnen de accolades “{” en “}”, omdat een array een verzameling elementen is met hetzelfde gegevenstype.

Om terug te komen op onze bovenstaande verklaring: elke rij elementen moet tussen de accolades worden geschreven. De rijen en de elementen in elke rij moeten worden gescheiden door komma’s.

Let nu op de verklaring: je kunt krijgen dat er 3 rijen en 5 kolommen zijn, dus de JVM maakt 3 * 5 = 15 blokken geheugen. Deze blokken kunnen afzonderlijk worden aangeduid 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]

OPMERKING:
Als u nelementen wilt opslaan, begint de array-index bij nul en eindigt bij n-1.
Een andere manier om een tweedimensionale array te maken, is door eerst de array te declareren en er vervolgens geheugen voor toe te wijzen met behulp van de nieuwe operator.

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

Door de bovenstaande twee te combineren kunnen we schrijven:

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

Antwoord 3, autoriteit 6%

Je kunt ze maken op de manier die anderen hebben genoemd. Nog een punt om toe te voegen: je kunt zelfs een scheve tweedimensionale array maken met elke rij, die niet noodzakelijk hetzelfde aantal kolommen heeft, zoals deze:

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

Antwoord 4, autoriteit 4%

Het meest voorkomende idioom om een tweedimensionale array te maken met 5rijen en 10kolommen is:

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

_{U kunt ook het volgende gebruiken, wat meer lijkt op wat u hebt, hoewel u expliciet moet initialiseren elke rij:}

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

Antwoord 5

Het is ook mogelijk om het de volgende manier te verklaren. Het is geen goed ontwerp, maar het werkt.

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

Antwoord 6

Probeer:

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

Merk op dat in uw code alleen de eerste regel van de 2D-array wordt geïnitialiseerd naar 0.
Lijn 2 tot 5 bestaan ​​niet eens. Als u ze probeert af te drukken, krijgt u nullvoor iedereen van hen.

Antwoord 7

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

Antwoord 8

In Java kan een tweedimensionale array worden gedeclareerd als hetzelfde als een eendimensionale array. In een eendimensionale array kunt u schrijven als

 int array[] = new int[5];

waarin int een gegevenstype is, array[] een arraydeclaratie en new arrayeen array is met zijn objecten met vijf indexen.

Zo kun je een tweedimensionale array als volgt schrijven.

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

Hier is arrayeen int-gegevenstype. Ik heb eerst gedeclareerd op een eendimensionale array van dat type, daarna wordt een array met 3 rijen en 4 kolommen gemaakt.

In uw code

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

betekent dat je een tweedimensionale array hebt gemaakt, met vijf rijen. In
de eerste rij zijn er 10 kolommen. In Java kunt u de kolomgrootte voor elke rij naar wens selecteren.

Antwoord 9

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

Veel plezier!

Antwoord 10

Probeer het op deze manier:

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

Antwoord 11

Dit soort arrays staan in Java bekend als gekartelde arrays:

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

In dit scenario bevat elke rij van de array het verschillende aantal kolommen. In het bovenstaande voorbeeld houdt de eerste rij drie kolommen vast, de tweede rij bevat twee kolommen en houdt de derde rij vijf kolommen in. U kunt deze array initialiseren op compileertijd zoals hieronder:

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

U kunt eenvoudig alle elementen in uw array herhalen:

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

Antwoord 12

Eigenlijk heeft Java geen multidimensionale array in wiskundige zin. Wat Java heeft, is slechts een array van arrays, een array waarbij elk element ook een array is. Daarom is de absolute vereiste om het initialiseren de grootte van de eerste dimensie. Als de rest is opgegeven, maakt het een array die is bevolkt met standaardwaarde.

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

Het geeft ons ook een quirk. De grootte van de sub-array kan niet worden gewijzigd door meer elementen toe te voegen, maar we kunnen dit doen door een nieuwe reeks willekeurige omvang toe te wijzen.

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