Sintassi per la creazione di un array bidimensionale

Prendere in considerazione:

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

È così che crei un array bidimensionale con 5 righe e 10 colonne?

Ho visto questo codice online, ma la sintassi non aveva senso.

Prova quanto segue:

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

... che è una scorciatoia per qualcosa del genere:

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

Si noti che ogni elemento sarà inizializzato al valore predefinito int, 0in modo quanto sopra sono anche equivalente a:

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

Possiamo dichiarare un array bidimensionale e archiviare direttamente gli elementi al momento della sua dichiarazione come:

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

Qui int rappresenta elementi di tipo intero memorizzati nell'array e il nome dell'array è 'marchi'. int è il tipo di dati per tutti gli elementi rappresentati tra parentesi graffe "{" e "}" perché un array è una raccolta di elementi con lo stesso tipo di dati.

Tornando alla nostra dichiarazione scritta sopra: ogni riga di elementi dovrebbe essere scritta all'interno delle parentesi graffe. Le righe e gli elementi in ogni riga devono essere separati da una virgola.

Ora osserva l'istruzione: puoi ottenere ci sono 3 righe e 5 colonne, quindi la JVM crea 3 * 5 = 15 blocchi di memoria. Questi blocchi possono essere definiti individualmente come:

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]

NOTA:
se si desidera memorizzare n elementi, l'indice dell'array inizia da zero e termina in n-1 . Un altro modo per creare un array bidimensionale è dichiarare prima l'array e quindi assegnare memoria per esso utilizzando un nuovo operatore.

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

Combinando i due precedenti possiamo scrivere:

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

Puoi crearli proprio come altri hanno già detto. Un altro punto da aggiungere: puoi persino creare un array bidimensionale inclinato con ogni riga, non necessariamente con lo stesso numero di colonne, in questo modo:

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

Il linguaggio più comune per creare un array bidimensionale con 5 righe e 10 colonne è:

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

_{In alternativa, puoi utilizzare quanto segue, che è più simile a quello che hai, anche se devi inizializzare esplicitamente ogni riga:}

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

È anche possibile dichiararlo nel modo seguente. Non è un buon design, ma funziona.

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

Provare:

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

Si noti che nel codice solo la prima riga dell'array 2D è inizializzata su 0. Le righe da 2 a 5 non esistono nemmeno. Se provi a stamparli otterrai nullper ognuno di loro.

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, un array bidimensionale può essere dichiarato uguale a un array monodimensionale. In una matrice unidimensionale puoi scrivere come

  int array[] = new int[5];

dove int è un tipo di dati, array [] è una dichiarazione di array ed new arrayè un array con i suoi oggetti con cinque indici.

In questo modo, è possibile scrivere un array bidimensionale come segue.

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

Ecco arrayun tipo di dati int. Ho prima dichiarato su un array monodimensionale di quel tipo, quindi viene creato un array a 3 righe e 4 colonne.

Nel tuo codice

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

significa che hai creato un array bidimensionale, con cinque righe. Nella prima riga ci sono 10 colonne. In Java puoi selezionare la dimensione della colonna per ogni riga che desideri.

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

Godere!

Prova in questo modo:

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

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

Questi tipi di array sono noti come array frastagliati in Java:

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

In questo scenario, ogni riga dell'array contiene il diverso numero di colonne. Nell'esempio sopra, la prima riga conterrà tre colonne, la seconda riga conterrà due colonne e la terza riga conterrà cinque colonne. È possibile inizializzare questo array in fase di compilazione come di seguito:

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

Puoi iterare facilmente tutti gli elementi nel tuo array:

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

In realtà Java non ha un array multidimensionale in senso matematico. Ciò che Java ha è solo un array di array, un array in cui ogni elemento è anche un array. Ecco perché il requisito assoluto per inizializzarlo è la dimensione della prima dimensione. Se il resto è specificato, verrà creato un array popolato con il valore predefinito.

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

Ci dà anche una stranezza. La dimensione dell'array secondario non può essere modificata aggiungendo più elementi, ma possiamo farlo assegnando un nuovo array di dimensioni arbitrarie.

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