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];
convertendo la stringa in int
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
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int>[][] arr = { {>1>,>2> }, {>3>,>4> } };> >System.out.println(>'arr[0][0] = '> + arr[>0>][>0>]);> >}> }> |
>
>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:
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(); } }> |
>
stringa inversa Java
>
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
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int>[][][] arr = { { {>1>,>2> }, {>3>,>4> } }, { {>5>,>6> }, {>7>,>8> } } };> >System.out.println(>'arr[0][0][0] = '> + arr[>0>][>0>][>0>]);> >}> }> |
>
>Produzione
come convertire un numero intero in una stringa Java
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>