ARRAY MULTIDIMENSIONALI IN JAVA - TECHCODEVIEW.COM

Nozioni di base sugli array in Java Array multidimensionali può essere definito in parole semplici come array di array. I dati negli array multidimensionali vengono archiviati in formato tabellare (nell'ordine maggiore delle righe).

Sintassi:

tipo di dati [1a dimensione][2a dimensione][]..[Na dimensione] nome_array = nuovo tipo_dati [taglia1][taglia2]….[tagliaN];

Dove:

tipo di dati : tipo di dati da memorizzare nell'array. Ad esempio: int, char, ecc.
dimensione : la dimensione dell'array creato. Ad esempio: 1D, 2D, ecc.
nome_array : nome dell'array
taglia1, taglia2, …, tagliaN : Dimensioni delle dimensioni rispettivamente.

Esempi:

Two dimensional array: int[][] twoD_arr = new int[10][20];  Three dimensional array: int[][][] threeD_arr = new int[10][20][30];

Dimensioni degli array multidimensionali : Il numero totale di elementi che possono essere memorizzati in un array multidimensionale può essere calcolato moltiplicando la dimensione di tutte le dimensioni.

Per esempio: La matrice int[][] x = nuovo int[10][20] può memorizzare un totale di (10*20) = 200 elementi. Allo stesso modo, array int[][][] x = nuovo int[5][10][20] può memorizzare un totale di (5*10*20) = 1000 elementi.

Applicazione dell'array multidimensionale

● Gli array multidimensionali vengono utilizzati per archiviare i dati in formato tabellare. Ad esempio, la memorizzazione del numero di matricola e dei voti di uno studente può essere eseguita facilmente utilizzando array multidimensionali. Un altro utilizzo comune è archiviare le immagini in array 3D.

● Nelle domande di programmazione dinamica vengono utilizzati array multidimensionali che servono a rappresentare gli stati del problema.

● Oltre a questi, hanno anche applicazioni in molti problemi algoritmici standard come: moltiplicazione di matrici, rappresentazione di matrici di adiacenza nei grafici, problemi di ricerca su griglia

Array bidimensionale (Array 2D)

L'array bidimensionale è la forma più semplice di un array multidimensionale. Un array bidimensionale può essere visto come un array di array unidimensionali per una più facile comprensione.

Metodo di dichiarazione indiretto:

Dichiarazione – Sintassi:

  data_type[][] array_name = new data_type[x][y];   For example: int[][] arr = new int[10][20];

Inizializzazione – Sintassi:

  array_name[row_index][column_index] = value;   For example: arr[0][0] = 1;

Esempio: 1

Giava

import> java.io.*;> public> class> GFG {> > public> static> void> main(String[] args)> > {> > int> [][] arr => new> int> [> 10> ][> 20> ];> > arr[> 0> ][> 0> ] => 1> ;> > System.out.println(> 'arr[0][0] = '> + arr[> 0> ][> 0> ]);> > }> }>

Produzione

arr[0][0] = 1

Esempio: implementazione di un array 2D con valori predefiniti con matrice 4*4

Giava

public> class> TwoDArray {> > public> static> void> main(String[] args) {> > int> rows => 4> ;> > int> columns => 4> ;> > int> [][] array => new> int> [rows][columns];> > int> value => 1> ;> > for> (> int> i => 0>

; i   for (int j = 0; j   array[i][j] = value;  value++;  }  }  System.out.println('The 2D array is: ');  for (int i = 0; i   for (int j = 0; j   System.out.print(array[i][j] + ' ');  }  System.out.println();  }  } }>

Produzione

The 2D array is: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Spiegazione:

Il numero di righe e colonne viene specificato utilizzando le variabili righe e colonne. L'array 2D viene creato utilizzando l'operatore new, che alloca memoria per l'array. La dimensione dell'array è specificata da righe e colonne.

Metodo diretto di dichiarazione: Sintassi:

  data_type[][] array_name = {     {valueR1C1, valueR1C2, ....},      {valueR2C1, valueR2C2, ....}     };   For example: int[][] arr = {{1, 2}, {3, 4}};

Esempio:

Giava

import> java.io.*;> class> GFG {> > public> static> void> main(String[] args)> > {> > int> [][] arr = { {> 1> ,> 2> }, {> 3> ,> 4> } };> > for> (> int> i => 0> ; i <> 2> ; i++)> > for> (> int> j => 0> ; j <> 2> ; j++)> > System.out.println(> 'arr['> + i +> ']['> + j +> '] = '> > + arr[i][j]);> > }> }>

Produzione

arr[0][0] = 1 arr[0][1] = 2 arr[1][0] = 3 arr[1][1] = 4

Accesso agli elementi di array bidimensionali

Gli elementi negli array bidimensionali sono comunemente indicati con x[i][j] dove 'i' è il numero di riga e 'j' è il numero di colonna.

Sintassi:

x[row_index][column_index]

Per esempio:

int[][] arr = new int[10][20]; arr[0][0] = 1;

L'esempio sopra rappresenta l'elemento presente nella prima riga e nella prima colonna. Nota : Negli array se la dimensione dell'array è N. Il suo indice sarà compreso tra 0 e N-1. Pertanto, per row_index 2, il numero di riga effettivo è 2+1 = 3. Esempio:

Giava

Produzione

arr[0][0] = 1

Rappresentazione dell'array 2D in formato tabulare:

Un array bidimensionale può essere visto come una tabella con righe 'x' e colonne 'y' in cui il numero di riga varia da 0 a (x-1) e il numero di colonna varia da 0 a (y-1). Di seguito è mostrato un array bidimensionale 'x' con 3 righe e 3 colonne:

due-d

Stampa array 2D in formato tabellare:

Per visualizzare tutti gli elementi di un array bidimensionale, utilizzare i cicli for nidificati. Per questo sono necessari due cicli for, uno per attraversare le righe e un altro per attraversare le colonne.

Esempio:

Giava

import> java.io.*;> class> GFG {> > public> static> void> main(String[] args)> > {> > int> [][] arr = { {> 1> ,> 2> }, {> 3> ,> 4> } };> > for> (> int> i => 0> ; i <> 2> ; i++) {> > for> (> int> j => 0> ; j <> 2> ; j++) {> > System.out.print(arr[i][j] +> ' '> );> > }> > System.out.println();> > }> > }> }>

Produzione

1 2 3 4

Esempio: implementazione di un array 2D con input dell'utente

Giava

import> java.util.Scanner;> public> class> Main {> > public> static> void> main(String[] args)> > {> > Scanner scan => new> Scanner(System.in);> > System.out.print(> 'Enter number of rows: '> );> > int> rows = scan.nextInt();> > System.out.print(> 'Enter number of columns: '> );> > int> columns = scan.nextInt();> > int> [][] multidimensionalArray=> new> int> [rows][columns];> > // Now you can use the array like a regular> > // 2-dimensional array> > for> (> int> i => 0>

; i   for (int j = 0; j   multidimensionalArray[i][j]= (i + 1) * (j + 1);  }  }  for (int i = 0; i   for (int j = 0; j   System.out.print(multidimensionalArray[i][j]+ ' ');  }  System.out.println();  }  scan.close();  } }>

Produzione

Enter number of rows: 3 Enter number of columns: 3 1 2 3  2 4 6  3 6 9

Questo codice richiede all'utente di inserire il numero di righe e colonne per l'array bidimensionale. La classe Scanner viene utilizzata per leggere l'input dell'utente. Quindi crea un array bidimensionale di numeri interi con il numero specificato di righe e colonne e assegna a ciascun elemento dell'array i*j.
Se desideri creare un array multidimensionale con più di due dimensioni, puoi utilizzare lo stesso approccio per creare un array di array. Ad esempio, per creare una matrice tridimensionale, è possibile creare una matrice di matrici bidimensionali.

Array tridimensionale (Array 3D)

L'array tridimensionale è una forma complessa di array multidimensionale. Un array tridimensionale può essere visto come un array di array bidimensionali per una più facile comprensione.

Metodo di dichiarazione indiretto:

Dichiarazione – Sintassi:

  data_type[][][] array_name = new data_type[x][y][z];   For example: int[][][] arr = new int[10][20][30];

Inizializzazione – Sintassi:

  array_name[array_index][row_index][column_index] = value;   For example: arr[0][0][0] = 1;

Esempio:

Giava

import> java.io.*;> class> GFG {> > public> static> void> main(String[] args)> > {> > int> [][][] arr => new> int> [> 10> ][> 20> ][> 30> ];> > arr[> 0> ][> 0> ][> 0> ] => 1> ;> > System.out.println(> 'arr[0][0][0] = '> + arr[> 0> ][> 0> ][> 0> ]);> > }> }>

Produzione

arr[0][0][0] = 1

Metodo diretto di dichiarazione: Sintassi:

  data_type[][][] array_name = {     {     {valueA1R1C1, valueA1R1C2, ....},      {valueA1R2C1, valueA1R2C2, ....}     },     {     {valueA2R1C1, valueA2R1C2, ....},      {valueA2R2C1, valueA2R2C2, ....}     }     };   For example: int[][][] arr = { {{1, 2}, {3, 4}}, {{5, 6}, {7, 8}} };

Esempio:

Giava

import> java.io.*;> class> GFG {> > public> static> void> main(String[] args)> > {> > int> [][][] arr = { { {> 1> ,> 2> }, {> 3> ,> 4> } }, { {> 5> ,> 6> }, {> 7> ,> 8> } } };> > for> (> int> i => 0> ; i <> 2> ; i++)> > for> (> int> j => 0> ; j <> 2> ; j++)> > for> (> int> z => 0> ; z <> 2> ; z++)> > System.out.println(> 'arr['> + i> > +> ']['> > + j +> ']['> > + z +> '] = '> > + arr[i][j][z]);> > }> }>

Produzione

arr[0][0][0] = 1 arr[0][0][1] = 2 arr[0][1][0] = 3 arr[0][1][1] = 4 arr[1][0][0] = 5 arr[1][0][1] = 6 arr[1][1][0] = 7 arr[1][1][1] = 8

Accesso agli elementi di array tridimensionali

Gli elementi negli array tridimensionali sono comunemente indicati con x[i][j][k] dove 'i' è il numero dell'array, 'j' è il numero della riga e 'k' è il numero della colonna.

Sintassi:

x[array_index][row_index][column_index]

Per esempio:

int[][][] arr = new int[10][20][30]; arr[0][0][0] = 1;

L'esempio sopra rappresenta l'elemento presente nella prima riga e nella prima colonna del primo array nell'array 3D dichiarato.

Nota : Negli array se la dimensione dell'array è N. Il suo indice sarà compreso tra 0 e N-1. Pertanto, per row_index 2, il numero di riga effettivo è 2+1 = 3.

Esempio:

Giava

Produzione

arr[0][0][0] = 1

Rappresentazione della matrice 3D in formato tabellare:

Un array tridimensionale può essere visto come una tabella di array con righe 'x' e colonne 'y' in cui il numero di riga varia da 0 a (x-1) e il numero di colonna varia da 0 a (y-1). Di seguito è mostrato un array tridimensionale con 3 array contenenti 3 righe e 3 colonne:

Stampa array 3D in formato tabellare:

Per visualizzare tutti gli elementi di un array tridimensionale, utilizzare i cicli for nidificati. Per questo sono necessari tre cicli for, uno per attraversare gli array, il secondo per attraversare le righe e un altro per attraversare le colonne.

Esempio:

Giava

import> java.io.*;> class> GFG {> > public> static> void> main(String[] args)> > {> > int> [][][] arr = { { {> 1> ,> 2> }, {> 3> ,> 4> } },> > { {> 5> ,> 6> }, {> 7> ,> 8> } } };> > for> (> int> i => 0> ; i <> 2> ; i++) {> > for> (> int> j => 0> ; j <> 2> ; j++) {> > for> (> int> k => 0> ; k <> 2> ; k++) {> > System.out.print(arr[i][j][k] +> ' '> );> > }> > System.out.println();> > }> > System.out.println();> > }> > }> }>

Produzione

1 2 3 4 5 6 7 8

Inserimento di un array multidimensionale durante il runtime:

Questo argomento è costretto a prendere l'input definito dall'utente in un array multidimensionale durante il runtime. Si concentra sull'utente che innanzitutto fornisce tutti gli input al programma durante il runtime e dopo tutti gli input immessi, il programma fornirà di conseguenza l'output rispetto a ciascun input. È utile quando l'utente desidera prima inserire input per più casi di test con più valori diversi e dopo aver eseguito tutte queste operazioni, il programma inizierà a fornire l'output. Ad esempio, troviamo il numero totale di numeri pari e dispari in un array di input. Qui utilizzeremo il concetto di array bidimensionale.

Ecco alcuni punti che spiegano l'uso dei vari elementi nel prossimo codice:

Il numero intero della riga è considerato come il numero di casi di test e i valori delle colonne sono considerati come valori in ciascun caso di test.
Un ciclo for() viene utilizzato per aggiornare il numero del caso di test e un altro ciclo for() viene utilizzato per acquisire i rispettivi valori dell'array.
Una volta completati tutti gli input, vengono utilizzati ancora due cicli for() nello stesso modo per eseguire il programma in base alla condizione specificata.
La prima riga di input è il numero totale di TestCase.
La seconda riga mostra il numero totale dei primi valori dell'array.
La terza riga fornisce i valori dell'array e così via.

Implementazione:

Giava

import> java.io.*;> import> java.util.Scanner;> class> GFGTestCase {> > public> static> void> main(String[] args)> > {> > // Scanner class to take> > // values from console> > Scanner scanner => new> Scanner(System.in);> > // totalTestCases = total> > // number of TestCases> > // eachTestCaseValues => > // values in each TestCase as> > // an Array values> > int> totalTestCases, eachTestCaseValues;> > // takes total number of> > // TestCases as integer number> > totalTestCases = scanner.nextInt();> > // An array is formed as row> > // values for total testCases> > int> [][] arrayMain => new> int> [totalTestCases][];> > // for loop to take input of> > // values in each TestCase> > for> (> int> i => 0>

; i   eachTestCaseValues = scanner.nextInt();  arrayMain[i] = new int[eachTestCaseValues];  for (int j = 0; j   arrayMain[i][j] = scanner.nextInt();  }  } // All input entry is done.  // Start executing output  // according to condition provided  for (int i = 0; i   // Initialize total number of  // even & odd numbers to zero  int nEvenNumbers = 0, nOddNumbers = 0;  // prints TestCase number with  // total number of its arguments  System.out.println('TestCase ' + i + ' with '  + arrayMain[i].length  + ' values:');  for (int j = 0; j   System.out.print(arrayMain[i][j] + ' ');  // even & odd counter updated as  // eligible number is found  if (arrayMain[i][j] % 2 == 0) {  nEvenNumbers++;  }  else {  nOddNumbers++;  }  }  System.out.println();  // Prints total numbers of  // even & odd  System.out.println(  'Total Even numbers: ' + nEvenNumbers  + ', Total Odd numbers: ' + nOddNumbers);  }  } } // This code is contributed by Udayan Kamble.>

Produzione:

  Input:  2 2 1 2 3 1 2 3    Output:  TestCase 0 with 2 values: 1 2  Total Even numbers: 1, Total Odd numbers: 1 TestCase 1 with 3 values: 1 2 3  Total Even numbers: 1, Total Odd numbers: 2    Input:  3 8 1 2 3 4 5 11 55 66 5 100 101 55 35 108 6 3 80 11 2 1 5    Output:  TestCase 0 with 8 values: 1 2 3 4 5 11 55 66  Total Even numbers: 3, Total Odd numbers: 5 TestCase 1 with 5 values: 100 101 55 35 108  Total Even numbers: 2, Total Odd numbers: 3 TestCase 2 with 6 values: 3 80 11 2 1 5  Total Even numbers: 2, Total Odd numbers: 4