Array multidimensionali

• Array multidimensionali, sintassi generale
• Array bidimensionali
• Dichiarare, creare e inizializzare array bidimensionali
• Visualizzazione di un array bidimensionale sullo schermo
• Output veloce di un array bidimensionale
• “Lunghezze” di una matrice bidimensionale
• Esempio di utilizzo di un array bidimensionale: scacchiera
• Esempio di utilizzo di un array bidimensionale: moltiplicazione di matrici
• Array bidimensionali non rettangolari
• Array tridimensionali
• Array multidimensionali nel lavoro reale di un programmatore Java
• Problemi interessanti su array bidimensionali e tridimensionali

Cos'è un array Java unidimensionale?

Un array è un insieme ordinato di elementi dello stesso tipo, primitivo o riferimento. Informazioni generali sugli array (per lo più unidimensionali) possono essere trovate nell'articolo “ Array in Java ” e nel corso JavaRush . In questo articolo parleremo di array i cui elementi sono altri array. Tali array sono chiamati multidimensionali. Un array i cui elementi sono altri array, ovvero un array di array, è detto bidimensionale. Non tutti i linguaggi hanno array multidimensionali strutturati in questo modo, ma in Java è così.

Array multidimensionali Java, sintassi generale

In generale, gli array multidimensionali in Java hanno questo aspetto:

Data_type[dimension1][dimension2][]..[dimensionN] array_name = new data_type[size1][size2]….[sizeN];

Dov'è Data_typeil tipo di elementi nell'array. Può essere primitivo o riferimento (classe). Il numero di coppie di parentesi con dimensioninterno è la dimensione dell'array (nel nostro caso - N). array_name— nome dell'array size1...sizN— numero di elementi in ciascuna dimensione dell'array. Dichiarazione di array multidimensionali:

int[][] twoDimArray; //two-dimensional array
String[][][] threeDimArray; //three-dimensional array
double[][][][][] fiveDimArray; // five-dimensional array

Forse tutto ciò sembra molto astratto, quindi passiamo ora alle manifestazioni concrete degli array multidimensionali: bidimensionali e tridimensionali. Il fatto è che gli sviluppatori Java a volte utilizzano array bidimensionali, molto meno spesso - tridimensionali e array ancora più grandi sono estremamente rari. Molto probabilmente non li incontrerai.

Cos'è un array Java bidimensionale?

Un array bidimensionale in Java è un array di array, ovvero ogni cella contiene un riferimento a un array. Ma è molto più semplice presentarlo sotto forma di tabella che ha un determinato numero di righe (prima dimensione) e un determinato numero di colonne (seconda dimensione). Un array bidimensionale in cui tutte le righe hanno lo stesso numero di elementi è detto rettangolare.

Dichiarare, creare e inizializzare array bidimensionali

La procedura per dichiarare e creare un array bidimensionale è quasi la stessa del caso di un array unidimensionale:

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

Questa matrice ha 3 righe e 4 colonne. La dimensione di un array bidimensionale rettangolare (potrebbero non essere rettangolari, ne parleremo più avanti), ovvero il numero totale di elementi può essere determinato moltiplicando il numero di righe per il numero di colonne. Ora è inizializzato (riempito) con i valori predefiniti. Cioè, zeri. Riempiamolo con i valori di cui abbiamo bisogno.

twoDimArray[0][0] = 5;//write the value 5 into the cell at the intersection of the zero row and zero column
twoDimArray[0][1] = 7; //write the value 7 into the cell at the intersection of the zero row and the first column
twoDimArray[0][2]  = 3;
twoDimArray[0][3] = 17;
twoDimArray[1][0] = 7;
twoDimArray[1][1] = 0;
twoDimArray[1][2] = 1;
twoDimArray[1][3] = 12;
twoDimArray[2][0] = 8;
twoDimArray[2][1] = 1;
twoDimArray[2][2] = 2;
twoDimArray[2][3] = 3;

Come per gli array unidimensionali, è possibile eseguire la procedura di inizializzazione più velocemente:

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};

In entrambi i casi otterremo un array bidimensionale con tre righe e quattro colonne, piene di numeri interi.

Visualizzazione di un array bidimensionale sullo schermo

Il modo più logico per eseguire questa operazione è restituire prima la linea dello zero elemento per elemento, quindi il secondo e così via. Il modo più comune per generare un array bidimensionale in Java è utilizzare due cicli nidificati.

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};//declared an array and filled it with elements
for (int i = 0; i < 3; i++) {  //go through the lines
            for (int j = 0; j < 4; j++) {//go through the columns
                System.out.print(" " + twoDimArray[i][j] + " "); //output element
            }
            System.out.println();// line wrap for the visual preservation of the tabular form
        }

Output veloce di un array bidimensionale

Il modo più breve per visualizzare sullo schermo un elenco di elementi di un array bidimensionale è utilizzare il metodo deepToStringclass Arrays. Esempio:

int[][] myArray = {{18,28,18},{28,45,90},{45,3,14}};
System.out.printLn(Arrays.deepToString(myArray));

Il risultato del programma è il seguente output: [[18, 28, 18], [28, 45, 90], [45, 3, 14]]

“Lunghezze” di una matrice bidimensionale

Per ottenere la lunghezza di un array unidimensionale (ovvero il numero di elementi in esso contenuti), puoi utilizzare la variabile length. Cioè, se definiamo un array int a[] = {1,2,3}, allora l'operazione a.lengthrestituisce 3. Ma cosa succede se applichiamo la stessa procedura al nostro array bidimensionale?

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};
System.out.println(twoDimArray.length);

Output: 3 Quindi questa operazione restituisce il numero di righe nell'array. Come ottenere il numero di colonne? Se abbiamo a che fare con array bidimensionali rettangolari (cioè quelli in cui tutte le linee hanno la stessa lunghezza), allora possiamo applicare l'operazione twoDimArray[0].lengtho invece dell'elemento zero (essenzialmente la linea zero) - qualsiasi altro esistente. Possiamo farlo perché in Java, un array bidimensionale è un array di array e l'elemento zero twoDimArray[0]è un array di lunghezza 4. Puoi verificarlo tu stesso.

Esempio di utilizzo di un array bidimensionale: scacchiera

Gli array bidimensionali possono essere utilizzati per creare qualsiasi campo bidimensionale finito, ad esempio nei giochi, e in particolare negli scacchi. È facile pensare a una scacchiera come a uno schieramento bidimensionale. Puoi "allegare" la grafica a questo, ma per ora definiamo una scacchiera utilizzando i simboli e inviala alla console. La casella in basso a sinistra della scacchiera è dipinta di nero, quella successiva è bianca, così come quella sopra di essa. Quindi, il colore cambia ogni volta che ti sposti in una cella adiacente al lato. Per impostare la colorazione degli scacchi non manualmente, ma utilizzando un algoritmo, è possibile utilizzare un controllo di parità: se la somma dell'indice di riga e colonna è pari o zero, la cella sarà bianca, altrimenti sarà nera. Per questo controllo, utilizziamo l'operatore resto % nell'algoritmo. Poiché non stiamo lavorando con la grafica, ma con i simboli, indicheremo la cella bianca con la lettera W(bianca) e la cella nera con la lettera B(nera).

//set the chessboard as a two-dimensional array
String [][] chessBoard = new String[8][8];
        for (int i = 0; i< chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W";
                else chessBoard[i][j] = "B";
            }
        }

L'output del programma è il seguente: WBWBWBWBBWBWBWBWWBWBW BWBBWBWBWBWWBWBWBWBBW BWBWBWWBWBWBWBBWBWBWB W Tutto è come su una vera scacchiera, puoi controllarlo. Ora scriviamo un metodo per numerare correttamente le celle non nel linguaggio degli array, ma nel linguaggio degli "scacchi". La cella in basso a sinistra sulla scheda si chiama A1, mentre nel nostro array è chessBoard[7][0]. Associamo ogni coppia di indici di un array bidimensionale al loro equivalente “scacchistico”. Per fare ciò, utilizziamo due linee - " abcdefgh" e " 87654321" (in ordine inverso - per semplicità, in modo che la scacchiera 8 corrisponda alla colonna zero).

public static String chessBoardCoord(int a, int b) {
            String letters = "abcdefgh";
            String numbers = "87654321";
            if ((a > 7)|| (b>7)) return null; //if the number is outside the board, return the default value - null
            else return (Character.toString(letters.charAt(a)) + numbers.charAt(b)); /*charAt - a method with which we extract from the string the element under the passed number, here - under the numbers a and b. Character.toString - a method that converts the received character into a string */
        }

Ora visualizziamo in ogni cella non solo il suo colore, ma anche il suo numero, utilizzando il metodochessBoardCoord

String [][] chessBoard = new String[8][8];
        for (int i = 0; i < chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W" + chessBoardCoord(j,i);
                else chessBoard[i][j] = "B"+ chessBoardCoord(j,i);
            }
        }

            for (int i = 0; i < chessBoard.length; i++) {
                for (int j = 0; j < chessBoard[0].length; j++) {
                    System.out.print(" " + chessBoard[i][j] + " ");
                }
                System.out.println();
            }

Uscita del programma: Wa8 Bb8 Wc8 Bd8 We8 Bf8 Wg8 Bh8 Ba7 Wb7 Bc7 Wd7 Be7 Wf7 Bg7 Wh7 Wa6 Bb6 Wc6 Bd6 We6 Bf6 Wg6 Bh6 Ba5 Wb5 Bc5 Wd5 Be5 Wf5 Bg5 Wh5 Wa4 Bb4 Wc4 Bd4 We4 Bf4 Wg4 Bh4 Ba3 Wb3 Bc3 Wd 3 Be3 Ff3 Bg3 Wh3 Wa2 Bb2 Wc2 Bd2 We2 Bf2 Wg2 Bh2 Ba1 Wb1 Bc1 Wd1 Be1 Wf1 Bg1 Wh1 Dove We2significa il quadrato bianco numerato e2.

Esempio di utilizzo di un array bidimensionale: moltiplicazione di matrici

Attenzione!Questo esempio richiede una conoscenza di base delle matrici. Qui si dirà molto poco su di loro, e queste informazioni sono destinate a coloro che hanno studiato, ma hanno un po' dimenticato, l'aritmetica delle matrici. Tuttavia, questa conoscenza può essere raccolta da fonti aperte, in particolare da un articolo su Wikipedia . Questo è un buon esempio di utilizzo di array bidimensionali, ma possiamo andare avanti senza di esso. Quindi, se ora ti sembra incomprensibile da un punto di vista matematico e non vuoi davvero approfondirlo, sentiti libero di saltare l'esempio. Se hai studiato l'algebra lineare di base, potresti aver imparato a conoscere gli array rettangolari come matrici rettangolari. Dove a11, a12... aNN sono alcuni numeri. Nella figura la matrice non è nemmeno rettangolare, ma quadrata (il numero di righe è uguale al numero di colonne, ma non è sempre così). Nella vita reale, tali matrici si incontrano raramente, ma nella programmazione e nell'informatica sono molto comuni. In particolare, vengono utilizzati nella computer grafica e nei motori di gioco. Ad esempio, la rotazione di un oggetto sullo schermo rispetto a qualsiasi angolo può essere programmata utilizzando una matrice di rotazione. Nello spazio bidimensionale, la matrice di rotazione si presenta così: Dove theta è l'angolo di cui l'oggetto deve essere ruotato. Matrici di uguali dimensioni possono essere sommate tra loro e l'addizione avviene elemento per elemento (aggiungiamo elementi con gli stessi indici). Ma l’operazione di moltiplicazione delle matrici è meno familiare. Pertanto è possibile moltiplicare le matrici e ottenere una matrice risultante solo se il numero di colonne della prima matrice coincide con il numero di righe della seconda. La matrice dei risultati avrà lo stesso numero di righe della prima e lo stesso numero di colonne della seconda. La moltiplicazione viene eseguita come segue. Prendiamo una matrice a[l][m]e b[m][n]. Come risultato della loro moltiplicazione dovremmo ottenere una matrice c[l][n]. Per ottenere un elemento di c[0][0]una matrice prodotto, è necessario a[0][0]moltiplicare l'elemento zero della riga zero della prima matrice per l'elemento zero della seconda matrice, quindi moltiplicare il primo elemento della prima riga della prima matrice per il primo elemento della prima colonna della seconda matrice, e così via, dopodiché vengono sommati tutti i prodotti risultanti.

a[0][0]*b[0][0] + a[0][1]*b[1][0] + … + a[0][m-1]*b[m-1][0]

Per ottenere il secondo elemento della prima riga della matrice dei risultati, eseguiamo la stessa procedura con la seconda riga

a[1][0]*b[0][0] + a[1][1]*b[0][1] + … + a[0][m-1]*b[m-1][0]

E così via fino alla fine della riga. Passiamo quindi alla riga successiva e ripetiamo la procedura finché non esauriamo le righe. Cioè moltiplichiamo le righe della prima matrice per le colonne della seconda matrice. Di seguito è riportato il codice per la moltiplicazione di matrici. Puoi integrarlo con un controllo del rispetto della condizione sopra menzionata sul numero di righe e colonne.

//declaring two matrices
int [][] twoDimArray1 = {{1,0,0,0},{0,1,0,0},{0,0,0,0}};
int[][] twoDimArray2 = {{1,2,3},{1,1,1},{0,0,0},{2,1,0}};

//matrix multiplication process
int[][]twoDimArray3 = new int [twoDimArray1.length][twoDimArray2[0].length];
        for (int i=0; i<twoDimArray3[0].length; i++)
            for (int j=0; j<twoDimArray3.length; j++)
                for (int k=0; k<twoDimArray1[0].length; k++)
                              twoDimArray3[i][j] = twoDimArray3[i][j] + twoDimArray1[i][k] * twoDimArray2[k][j];

//output on display
        for (int i = 0; i < twoDimArray3.length; i++) {
            for (int j = 0; j < twoDimArray3[0].length; j++) {
                System.out.print(" " + twoDimArray3[i][j] + " ");
            }
            System.out.println();
        }

Il programma restituisce il seguente risultato: 1 2 3 1 1 1 0 0 0

Array bidimensionali non rettangolari

Poiché in Java gli array bidimensionali sono array di array, ciascuno degli array interni può avere lunghezze diverse. Quando creiamo un array possiamo specificare solo il numero di righe e non il numero di colonne (cioè, appunto, la lunghezza di queste stesse righe). Diamo un'occhiata a un esempio.

//declaring and creating an array, specifying only the number of rows
int [][] twoDimArray = new int[5][];

//initialize the array, filling it with arrays of different lengths
        twoDimArray[0] = new int[]{1, 2, 3, 4, 5};
        twoDimArray[1] = new int[]{1,2,3,4};
        twoDimArray[2] = new int[]{1,2,3};
        twoDimArray[3] = new int[]{1,2};
        twoDimArray[4] = new int[]{1};
//display the resulting non-rectangular two-dimensional array on the screen
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                System.out.print(" " + twoDimArray[i][j] + " ");
            }
            System.out.println();
        }

Output del programma: 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1 Pertanto, la riga zero del nostro array contiene l'array {1,2,3,4,5}e la quarta riga contiene l'array {1}.

Array tridimensionali in Java

Seguendo il buon senso e la logica del linguaggio Java, un array tridimensionale può essere chiamato “array di array di array” o “array in cui ciascun elemento è un array bidimensionale”. Inoltre, questi array bidimensionali possono essere diversi. Esempio:

// create a three-dimensional array consisting of two two-dimensional arrays
int[][][] threeDimArr = new int[2][][];
//create the first 2D array of a 5x2 3D array
        threeDimArr[0] = new int[5][2];
//create a second 2D array of a 1x1 3D array
        threeDimArr[1] = new int[1][1];

Ma più spesso nella pratica ci sono matrici tridimensionali in cui tutte e tre le quantità sono definite contemporaneamente, un analogo delle matrici bidimensionali rettangolari. Come abbiamo già accennato, gli array tridimensionali o più vengono utilizzati molto raramente. Tuttavia, puoi programmare qualcosa di interessante con un array 3D. Ad esempio un parcheggio multipiano. Ogni piano può essere considerato una matrice bidimensionale e un parcheggio può essere considerato un elemento specifico di una matrice tridimensionale. Un elemento di tale array può essere rappresentato da un tipo booleancon il valore false se lo spazio è libero e true se lo spazio è occupato.

//set a boolean three-dimensional array. This car park has 3 floors, each of which can accommodate 2x5 = 10 cars. By default, all cells are empty (false)
boolean[][][] parkingLot = new boolean[3][2][5];
//two cars arrived and parked on the ground floor in cell [1][0] and [1][3]
        parkingLot[0][1][0] = true;
        parkingLot[0][1][3] = true;

//Output the array to the console
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 5; k++) {
                    System.out.print("arr[" + i + "][" + j + "][" + k + "] = " + parkingLot[i][j][k] + "\t");

                }
                System.out.println();
            }
        }

Problemi interessanti su array bidimensionali e tridimensionali

Ne sai abbastanza degli array multidimensionali in Java e, se ti senti sicuro, puoi provare a risolvere alcuni dei problemi seguenti. Non sono facili, ma interessanti. Tris. Prepara un campo 3x3, crea due giocatori che si alternano. Inizialmente il campo è vuoto e in ciascuno dei campi vuoti il ​​primo giocatore può mettere una croce e il secondo uno zero. Il vincitore è colui che per primo raccoglie tre croci o tre zeri disposti su una riga, una colonna o in diagonale. La formica di Langton . C'è un certo campo, diviso in celle (un array bidimensionale), dipinto di bianco o nero (può essere impostato da una funzione casuale). Una "formica" si materializza casualmente in una delle celle e ad ogni passo può spostarsi in una delle quattro direzioni verso la cella adiacente, orizzontalmente o verticalmente. Regole per il movimento delle formiche:

• Su un quadrato nero, la formica deve girarsi di 90° a sinistra, cambiare il colore della sua cella in bianco, quindi avanzare al quadrato successivo.
• Su un quadrato bianco, la formica gira di 90° a destra e cambia il colore della sua cella in nero, quindi avanza verso il quadrato successivo.

Scrivi un metodo che calcoli l'iterazione al passo numero ndata la posizione iniziale della formica. Il campo può essere riempito in modo casuale con zeri e uno (o indicato con le lettere We B, come abbiamo fatto nell'esempio della scacchiera). Abbiamo bisogno anche di altri due parametri: la posizione orizzontale e verticale della formica, nonché la sua direzione in questo passaggio (nord, sud, ovest, est), mentre per impostazione predefinita la formica guarda a nord. Puoi provare a modellare un cubo di Rubik utilizzando array tridimensionali. Un cubo di Rubik standard ha 6 facce e ognuna di esse è una serie tridimensionale di quadrati colorati Color[][][] rubik = new Color[6][3][3]. Tuttavia, implementare un cubo di Rubik non è un compito banale.

Materiali utili sugli array

Molti articoli su JavaRush sono dedicati agli array (principalmente quelli unidimensionali, poiché nella pratica vengono utilizzati molto più spesso). Presta attenzione a loro.

1. Array in Java : sugli array per principianti con esempi
2. Qualcosa sugli array - Buon articolo dettagliato sugli array
3. La classe Arrays e il suo utilizzo : l'articolo descrive alcuni metodi della classeArray
4. Arrays è la prima conferenza JavaRush dedicata agli array.
5. Restituisci un array di lunghezza zero, non nullo - L'autore di Effective Programming Joshua Bloch parla di come restituire meglio array vuoti