multidimensional arrays java 2d
Questo tutorial sugli array multidimensionali in Java illustra come inizializzare, accedere e stampare array 2d e 3d in Java con esempi di sintassi e codice:
Finora abbiamo discusso i principali concetti sugli array unidimensionali. Questi array memorizzano una singola sequenza o un elenco di elementi dello stesso tipo di dati.
Java supporta anche array con più di una dimensione e questi sono chiamati array multidimensionali.
=> Controlla TUTTI i tutorial Java qui.
Gli array multidimensionali Java sono organizzati come array di array, ovvero ogni elemento di un array multidimensionale è un altro array. La rappresentazione degli elementi è in righe e colonne. Pertanto, è possibile ottenere un numero totale di elementi in un array multidimensionale moltiplicando la dimensione della riga per la dimensione della colonna.
cosa fare con un file torrent
Quindi, se hai un array bidimensionale di 3 × 4, il numero totale di elementi in questo array = 3 × 4 = 12.
In questo tutorial, esploreremo gli array multidimensionali in Java. Per prima cosa discutiamo gli array bidimensionali prima di passare agli array tridimensionali.
Cosa imparerai:
- Array bidimensionale
- Array multidimensionali Java
- Array tridimensionali in Java
- Domande frequenti
- Conclusione
Array bidimensionale
Il più semplice dell'array multidimensionale è un array bidimensionale. Una semplice definizione di array 2D è: un array 2D è un array di array unidimensionali.
In Java, un array bidimensionale viene memorizzato sotto forma di righe e colonne ed è rappresentato sotto forma di una matrice.
La dichiarazione generale di un array bidimensionale è,
data_type [] [] array_name;
Qui,
data_type = tipo di dati degli elementi che verranno memorizzati in un array.
array_name = nome dell'array bidimensionale.
È possibile creare un array 2D utilizzando new come segue:
data_type [] [] array_name = new data_type[row_size][column_size];
Qui,
row_size = numero di righe che un array conterrà.
column_size = numero di colonne che l'array conterrà.
Quindi, se hai un array di 3 × 3, significa che avrà 3 righe e 3 colonne.
Il layout di questo array sarà come mostrato di seguito.
Righe / Colonne | Colonna1 | Colonna2 | Colonna3 |
---|---|---|---|
Row1 | [0,0] | [0.1] | [0.2] |
Row2 | [1.0] | [1,1] | [1,2] |
Row3 | [2.0] | [2.1] | [2.2] |
Come mostrato sopra, ogni intersezione di riga e colonna memorizza un elemento della matrice 2D. Quindi, se vuoi accedere al primo elemento nell'array 2d, allora è dato da [0, 0].
Nota poiché la dimensione dell'array è 3 × 3, puoi avere 9 elementi in questo array.
Un array di numeri interi denominato 'myarray' di 3 righe e 2 colonne può essere dichiarato come di seguito.
int [][] myarray = new int[3][2];
Una volta che l'array è stato dichiarato e creato, è tempo di inizializzarlo con i valori.
Inizializza 2d Array
Esistono vari modi per inizializzare l'array 2d con i valori. Il primo metodo è il metodo tradizionale di assegnazione di valori a ciascun elemento.
La sintassi generale per l'inizializzazione è:
array_name[row_index][column_index] = value;
Esempio:
int[][] myarray = new int[2][2]; myarray[0][0] = 1; myarray[0][1] = myarray[1][0] = 0; myarray[1][1] = 1;
Le istruzioni precedenti inizializzano tutti gli elementi del dato array 2d.
Inseriamolo in un programma e controlliamo l'output.
public class Main { public static void main(String[] args) { int[][] myarray = new int[2][2]; myarray[0][0] = 1; myarray[0][1] = myarray[1][0] = 0; myarray[1][1] = 1; System.out.println('Array elements are:'); System.out.println(myarray[0][0] + ' ' +myarray[0][1]); System.out.println(myarray[1][0] + ' ' +myarray[1][1]); } }
Produzione:
Questo metodo può essere utile quando le dimensioni coinvolte sono più piccole. Man mano che la dimensione dell'array cresce, è difficile utilizzare questo metodo per inizializzare individualmente gli elementi.
Il metodo successivo per inizializzare l'array 2d in Java è inizializzare l'array solo al momento della dichiarazione.
La sintassi generale per questo metodo di inizializzazione è la seguente:
data_type[][] array_name = {{val_r1c1,val_r1c2,...val_r1cn}, {val_r2c1, val_r2c2,...val_r2cn}, … {val_rnc1, val_rnc2,…val_rncn}};
Per esempio, se hai un array 2 × 3 di tipo int, allora puoi inizializzarlo con la dichiarazione come:
int [][] intArray = {{1, 2, 3}, {4, 5, 6}};
L'esempio seguente mostra la dichiarazione di matrice 2d con inizializzazione.
public class Main { public static void main(String[] args) { //2-d array initialised with values int[][] intArray = { { 1, 2 }, { 3, 4 },{5,6}}; //print the array System.out.println('Initialized Two dimensional array:'); for (int i = 0; i <3; i++) { for (int j = 0; j < 2; j++) { System.out.print(intArray [i][j] + ' '); } System.out.println(); } } }
Produzione:
Nel programma precedente, l'array viene inizializzato al momento della dichiarazione stessa e quindi vengono visualizzati i valori.
È inoltre possibile inizializzare o assegnare i valori all'array 2d utilizzando un ciclo come mostrato di seguito.
int[][] intArray = new int[3][3]; for (int i = 0; i <3; i++) { for (int j = 0; j < 3; j++) { intArray[i][j] = i+1; } }
Il seguente programma implementa il codice precedente.
public class Main { public static void main(String[] args) { //declare an array of int int[][] intArray = new int[3][3]; System.out.println('Array elements are:'); for (int i = 0; i <3; i++) { for (int j = 0; j < 3; j++) { intArray[i][j] = i+1; //assign values to each array element System.out.print(intArray[i][j] + ' '); //print each element } System.out.println(); } } }
Produzione:
A ogni elemento nella matrice 2d sopra viene assegnato un valore 'i + 1'. Questo fa sì che ogni elemento in una riga dell'array contenga lo stesso valore.
Accedi e stampa 2d Array
Sai già che quando si inizializza l'array 2d, puoi inizializzare i singoli elementi dell'array su un valore. Questa operazione viene eseguita utilizzando l'indice di riga e l'indice di colonna della matrice per accedere a un particolare elemento.
Simile all'inizializzazione, puoi anche accedere al valore del singolo elemento e stamparlo per l'utente.
La sintassi generale per accedere all'elemento array è:
data_typeval = array_name[row_index][column_index];
Dove array_name è l'array a cui si accede all'elemento e data_type è lo stesso del tipo di dati dell'array.
Il seguente programma mostra come accedere e stampare un singolo elemento.
public class Main { public static void main(String[] args) { //two dimensional array definition int[][] intArray = {{1,2},{4,8}}; //Access individual element of array intval = intArray[0][1]; //print the element System.out.println('Accessed array value = ' + val); System.out.println('Contents of Array:' ); //print individual elements of array System.out.println(intArray[0][0] + ' ' + intArray[0][1]); System.out.println(intArray[1][0] + ' ' + intArray[1][1]); } }
Produzione:
In questo modo è possibile accedere e stampare facilmente i singoli elementi dell'array utilizzando gli indici di riga e colonna racchiusi tra parentesi quadre ([]).
Puoi stampare l'intero array in una volta in un formato tabulare come mostrato sopra (chiamato anche modulo a matrice) usando il ciclo for. Poiché si tratta di un array bidimensionale, è necessario disporre di due loop per questo. Un ciclo per scorrere le righe, ovvero il ciclo esterno e il ciclo interno per attraversare le colonne.
In un dato istante (iterazione corrente), l'elemento particolare dell'array è dato da,
nome_array [i] [j];
Dove 'i' è la riga corrente e 'j' è la colonna corrente.
Il seguente programma mostra la stampa di un array 2d utilizzando un ciclo 'for'.
public class Main { public static void main(String[] args) { //two dimensional array definition int[][] intArray = new int[3][3]; //printing the 2-d array System.out.println('The two-dimensional array:'); for (int i = 0; i <3; i++) { for (int j = 0; j < 3; j++) { intArray[i][j] = i*j; //assign value to each array element System.out.print(intArray [i][j] + ' '); } System.out.println(''); } } }
Produzione:
Nel programma precedente, l'array 2d viene inizializzato e quindi gli elementi vengono stampati utilizzando due cicli for. Quello esterno viene utilizzato per tenere traccia delle righe mentre il ciclo for interno è per le colonne.
Lunghezza array Java 2d
Una matrice bidimensionale è definita come la matrice di una matrice unidimensionale. Pertanto, quando è necessaria la lunghezza di un array 2d, non è così semplice come in un array unidimensionale.
La proprietà length per una matrice bidimensionale restituisce il numero di righe nella matrice. Ogni riga è una matrice unidimensionale. Sai già che l'array bidimensionale è composto da righe e colonne. La dimensione della colonna può variare per ogni riga.
Quindi puoi ottenere la dimensione di ogni riga ripetendo il numero di righe.
Il seguente programma fornisce la lunghezza della matrice (numero di righe) e la dimensione di ciascuna riga.
public class Main { public static void main(String[] args) { //initialize 2-d array int[][] myArray = { { 1, 2, 3 }, { 4, 5 } }; System.out.println('length of array:' + myArray.length); //number of rows for(int i=0;i Produzione:
Una matrice bidimensionale definita sopra ha due righe. Ogni riga è una matrice unidimensionale. Il primo array 1D ha 3 elementi (3 colonne) mentre la seconda riga ha 2 elementi.
Il seguente programma Java mostra l'utilizzo della proprietà length per stampare l'array 2d.
public class Main { public static void main(String[] args) { //two dimensional array definition int[][] myarray = new int[3][3]; //printing the 2-d array System.out.println('The two-dimensional array:'); for (int i = 0; i Produzione:
Come già accennato, il ciclo esterno rappresenta le righe e il ciclo for interno rappresenta le colonne.
Nota: La condizione di terminazione in entrambi i cicli utilizza la proprietà length, prima per scorrere le righe e poi per le colonne.
Array multidimensionali Java
Abbiamo già visto array bidimensionali. Java supporta array con più di due dimensioni.
La sintassi generale di un array multidimensionale è la seguente:
data_type [d1][d2]…[dn] array_name = new data_type[d1_size][d2_size]…[dn_size];
Qui,
d1, d2… dn = dimensioni della matrice multidimensionale
[d1_size] [d2_size]… [dn_size] = rispettive dimensioni delle dimensioni
data_type = tipo di dati degli elementi dell'array
array_name = nome dell'array multidimensionale
Come esempio di un altro array multidimensionale diverso dall'array 2d, esaminiamo i dettagli degli array tridimensionali (3d).
Array tridimensionali in Java
Abbiamo già discusso del fatto che un array diventa più complesso con l'aumentare delle dimensioni. Gli array tridimensionali sono complessi per gli array multidimensionali. Un tridimensionale può essere definito come un array di array bidimensionali.
Di seguito viene fornita la definizione generale di array tridimensionale:
data_type [] [] [] array_name = new data_type [d1][d2][d3];
Qui,
d1, d2, d3 = dimensioni delle dimensioni
data_type = tipo di dati degli elementi dell'array
array_name = nome dell'array 3d
Esempio di definizione di array 3d è:
int [] [] [] intArray = new int[2][3][4];
La precedente definizione di array 3d può essere interpretata come se avesse 2 tabelle o array, 3 righe e 4 colonne che totalizzano fino a 2x3x4 = 24 elementi.
Ciò significa che in un array 3D, le tre dimensioni vengono interpretate come:
- Il numero di tabelle / array: La prima dimensione indica quante tabelle o array avrà un array 3D.
- Il numero di righe: La seconda dimensione indica il numero totale di righe che avrà un array.
- Il numero di colonne: La terza dimensione indica le colonne totali nell'array 3d.
Inizializza array 3d
Gli approcci utilizzati per inizializzare un array 3d sono gli stessi di quelli utilizzati per inizializzare gli array bidimensionali.
È possibile inizializzare l'array assegnando valori ai singoli elementi dell'array o inizializzare l'array durante la dichiarazione.
L'esempio seguente mostra l'inizializzazione dell'array 3d durante la dichiarazione.
public class Main { public static void main(String[] args) { //initialize 3-d array int[][][] intArray = { { { 1, 2, 3}, { 4, 5, 6 } , { 7, 8, 9 } } }; System.out.println ('3-d array is given below :'); //print the elements of array for (int i = 0; i <1; i++) for (int j = 0; j < 3; j++) for (int z = 0; z < 3; z++) System.out.println ('intArray [' + i + '][' + j + '][' + z + '] = ' + intArray [i][j][z]); } }
Produzione:
Dopo aver inizializzato l'array 3d durante la dichiarazione, abbiamo avuto accesso ai singoli elementi dell'array e li abbiamo stampati.
Accesso e stampa 3d array
Di nuovo, la stampa e l'accesso agli elementi di un array in un array tridimensionale è simile a quello degli array bidimensionali.
Il programma seguente utilizza i cicli for per accedere agli elementi dell'array e stamparli sulla console.
public class Main { public static void main(String[] args) { //initialize 3-d array int[][][] myArray = { { { 1, 2, 3 }, { 4, 5, 6 } }, { { 1, 4, 9 }, { 16, 25, 36 } }, { { 1, 8, 27 }, { 64, 125, 216 } } }; System.out.println('3x2x3 array is given below:'); //print the 3-d array for (int i = 0; i <3; i++) { for (int j = 0; j < 2; j++) { for (int k = 0; k < 3; k++) { System.out.print(myArray[i][j][k] + ' '); } System.out.println(); } System.out.println(); } } }
Produzione:
Il programma sopra mostra una rappresentazione tabellare di un array tridimensionale. Come mostrato, è un array 3x2x3, il che significa che ha 3 tabelle, 2 righe e 3 colonne e quindi 18 elementi.
È già stato detto che la dimensione della colonna può variare in una matrice multidimensionale. L'esempio seguente mostra una matrice tridimensionale con colonne di dimensioni variabili.
Questo programma utilizza anche un ciclo for migliorato per attraversare l'array e visualizzare i suoi elementi.
public class Main { public static void main(String[] args) { //initialize 3-d array int[][][] intArray = { {{10, 20, 30},{20, 40, 60}}, { {10, 30,50,70},{50},{80, 90}} }; System.out.println('Multidimensional Array (3-d) is as follows:'); // use for..each loop to iterate through elements of 3d array for (int[][] array_2D: intArray) { for (int[] array_1D: array_2D) { for(intelem: array_1D) { System.out.print(elem + ' '); } System.out.println(); } System.out.println(); } } }
Produzione:
La matrice di input utilizzata è una matrice tridimensionale con una lunghezza variabile di colonne. Il miglioramento per ogni ciclo utilizzato per ogni dimensione visualizza il contenuto della matrice in formato tabulare.
Domande frequenti
Q # 1) Cosa intendi per array bidimensionale?
Risposta: Un array bidimensionale è chiamato array di array ed è solitamente organizzato sotto forma di matrici costituite da righe e colonne. Un array bidimensionale trova il suo utilizzo principalmente in database relazionali o strutture dati simili.
D # 2) Che cos'è un array monodimensionale in Java?
Risposta: Un array unidimensionale in Java è un array con un solo indice. Questa è la forma più semplice di array in Java.
D # 3) Qual è la differenza tra un array unidimensionale e un array bidimensionale?
Risposta: La matrice unidimensionale memorizza una singola sequenza di elementi e ha un solo indice. Un array bidimensionale memorizza un array di array di elementi e utilizza due indici per accedere ai suoi elementi.
Q # 4) Cosa significa essere bidimensionale?
Risposta: Bidimensionale significa avere solo due dimensioni. In un mondo geometrico, gli oggetti che hanno solo altezza e larghezza sono oggetti bidimensionali o 2D. Questi oggetti non hanno spessore o profondità.
Triangoli, rettangoli, ecc. Sono oggetti 2D. In termini di software, bidimensionale significa ancora avere due dimensioni e di solito definiamo strutture di dati come array che possono avere 1, 2 o più dimensioni.
aggiungere a un array in java
D # 5) Quale viene prima in un array: righe o colonne?
Risposta: Gli array bidimensionali sono rappresentati come matrici e le matrici sono solitamente scritte in termini di righe x colonne. Per esempio, una matrice di dimensione 2 × 3 avrà 2 righe e 3 colonne. Quindi anche per l'array 2D, le righe vengono prima e le colonne dopo.
Conclusione
Si trattava di array multidimensionali in Java. Abbiamo discusso tutti gli aspetti degli array bidimensionali e di un array con più di due dimensioni.
Questi sono solitamente chiamati array o array poiché, nel caso di array multidimensionali, ogni elemento è un altro array. Quindi, possiamo dire che un array contiene un altro array o semplicemente un array di array.
Nei nostri prossimi tutorial, esploreremo di più sugli array e poi passeremo ad altre raccolte.
=> Guarda qui la serie di formazione su Java semplice.
Lettura consigliata
- Java Array - Come stampare elementi di un array in Java?
- Java Generic Array - Come simulare array generici in Java?
- Array multidimensionali e array irregolari in C #
- Introduzione agli array Java e concetti correlati
- Array multidimensionali in C ++
- Java DataType, loop, array, switch e asserzioni
- Array Java: dichiara, crea e inizializza un array in Java
- Tutorial sulla lunghezza di array Java con esempi di codice