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 syntax non aveva senso.

Prova quanto segue:

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

… che è una mano breve per qualcosa di simile:

 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 verrà inizializzato sul valore predefinito per int , 0 , quindi quanto sopra è 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 una matrice bidimensionale e memorizzare direttamente 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 gli elementi di tipo intero memorizzati nell’array e il nome dell’array è ‘marks’. int è il tipo di dati per tutti gli elementi rappresentati all’interno delle parentesi “{” e “}” perché una matrice è una raccolta di elementi con lo stesso tipo di dati.

Tornando alla nostra affermazione 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.

Osserva ora la frase: puoi ottenere che ci siano 3 righe e 5 colonne, quindi la JVM crea 3 * 5 = 15 blocchi di memoria. Questi blocchi possono essere indicati singolarmente 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 su n-1 . Un altro modo per creare un array bidimensionale è dichiarare prima l’array e quindi assegnargli memoria usando 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 gli altri hanno menzionato. Un altro punto da aggiungere: puoi anche creare una matrice bidimensionale inclinata con ogni riga, non necessariamente con lo stesso numero di colonne, come questa:

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

L’idioma più comune per creare un array bidimensionale con 5 righe e 10 colonne è:

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

In alternativa, è ansible utilizzare quanto segue, che è più simile a quello che si ha, anche se è necessario inizializzare esplicitamente ogni riga:

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

Provare:

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

Si noti che nel proprio codice solo la prima riga dell’array 2D viene inizializzata su 0. Le righe da 2 a 5 non esistono nemmeno. Se provi a stamparli, otterrai null per tutti loro.

In Java, un array bidimensionale può essere dichiarato uguale a un array monodesmensionale. In un array unidimensionale puoi scrivere come

  int array[] = new int[5]; 

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

In questo modo, puoi scrivere un array bidimensionale come segue.

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

Qui array è un tipo di dati int. In primo luogo ho dichiarato su un array unidimensionale di quel tipo, quindi viene creato un array di 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 come desideri.

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

 int[] twoDimIntArray[] = new int[5][10]; 
 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  
 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 matrici frastagliate 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 precedente, la prima riga contiene tre colonne, la seconda fila contiene due colonne e la terza fila contiene cinque colonne. Puoi inizializzare questo array in fase di compilazione come di seguito:

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

Puoi facilmente iterare tutti gli elementi dell’array:

 for (int i = 0; i