Array bidimensionali

Un frammento di lezione con un mentore come parte del corso Codegym University. Iscriviti al corso completo.

"Saluti, Amico!"

"Ciao Rishi!"

"Sai già una o due cose sugli array, e sei anche riuscito a risolvere alcuni problemi, spero. Ma non sai tutto. Ad esempio, ecco un altro fatto interessante sugli array. Gli array non sono solo unidimensionali (lineari ). Possono anche essere bidimensionali."

"Ehm... cosa significa?"

"Ciò significa che le celle dell'array possono rappresentare non solo una colonna (o riga), ma anche una tabella rettangolare.

int[][]name = new int[width][height];

"Dove name è il nome della variabile array, width è la larghezza della tabella (in celle) e height è l'altezza della tabella. Dai un'occhiata a un esempio:

int[][] data = new int[2][5];
data[1][1] = 5;

"Ecco come apparirà nella memoria:

"A proposito, per gli array bidimensionali, puoi anche usare l'inizializzazione rapida:

// Lengths of months of the year in each quarter
int[][] months = { {31, 28, 31}, {30, 31, 30}, {31, 31, 30}, {31, 30, 31} };

"Hmm... ora questo è interessante. Se immaginiamo che nella prima parentesi interna rappresenti un elemento, la successiva è un secondo... Quindi un array bidimensionale è come un array di array?"

"Che studente intelligente sei! Esattamente. Il primo elemento è l'array unidimensionale {31, 28, 31}, il secondo è {30, 31, 30}, e così via. Ma ci torneremo un po' più avanti in questa lezione. Fino ad allora, prova a pensare a un array bidimensionale come una tabella con righe e colonne, formando celle ad ogni intersezione.

"Ne ho un'immagine mentale. A proposito, a cosa servono questi array bidimensionali?"

"I programmatori hanno bisogno di array bidimensionali abbastanza spesso. Se guardi da vicino, quasi tutti i giochi da tavolo sono implementati utilizzando un array bidimensionale standard: scacchi, dama, tris, battaglia navale, ecc.:"

"Ho capito! Il campo di gioco degli scacchi o della battaglia navale si adatta perfettamente agli array bidimensionali!"

"Sì, ma devi usare i numeri come coordinate della cella. Non 'pedone e2-e4', ma 'pedone (5,2) -> (5,4)'. Sarà ancora più facile per te come programmatore. "

Disposizione degli elementi in array: (x, y) o (y, x)

"La creazione di array bidimensionali solleva un dilemma interessante. Quando creiamo un array utilizzando new int [2][5];, abbiamo una tabella di 'due righe e 5 colonne ' o è 'due colonne e 5 righe'?"

"In altre parole, non è del tutto chiaro se stiamo specificando prima la larghezza e poi l'altezza... o viceversa, prima l'altezza e poi la larghezza?"

"Sì, questo è il dilemma. E non c'è una risposta certa."

"Cosa fare?"

"In primo luogo, è importante capire come il nostro array bidimensionale è effettivamente memorizzato . Naturalmente, la memoria del computer non contiene alcuna tabella: ogni posizione in memoria ha un indirizzo numerico sequenziale: 0, 1, 2, ... Per noi questa è una tabella 2 × 5, ma in memoria sono solo 10 celle, niente di più. Nessuna divisione in righe e colonne."

"Questo l'ho capito. Allora come determiniamo quale dimensione viene prima: la larghezza o l'altezza?"

"Consideriamo la prima opzione. Prima la larghezza, poi l'altezza " . e poi 'y' (la dimensione verticale). E questo non è solo uno standard scolastico, è uno standard generalmente accettato in matematica. Come si suol dire, non si può discutere con la matematica."

"È così? Beh, se non possiamo combatterlo, allora prima la larghezza e poi l'altezza?"

"C'è un argomento interessante a favore di 'height first, then width' . Questo argomento deriva dalla rapida inizializzazione di array bidimensionali. Dopotutto, se vogliamo inizializzare il nostro array, allora scriviamo codice come questo:"

// Matrix of important data
int[][] matrix = { {1, 2, 3, 4, 5}, {1, 2, 3, 4, 5} };

"Allora cosa fa per noi?"

"Hai notato qualcosa? E se avessimo questo?

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {1, 2, 3, 4, 5}
};

"Se scriviamo i nostri dati nel codice riga per riga, otteniamo una tabella con 2 righe e 5 colonne."

"Ora capisco. 2 è l'altezza, e 5 è la larghezza... Allora quale opzione dovremmo usare?"

"Sta a te decidere quale è più conveniente. La cosa più importante è che tutti i programmatori che lavorano allo stesso progetto seguano lo stesso approccio."

"Se lavori su un progetto il cui codice ha molti array bidimensionali inizializzati, allora molto probabilmente tutto sarà basato su una rapida inizializzazione dei dati, cioè avrai lo standard 'altezza x larghezza'.

"Se ti trovi in ​​un progetto che coinvolge molta matematica e lavori con le coordinate (ad esempio, i motori di gioco), molto probabilmente il codice adotterà l'approccio 'larghezza x altezza'.

Come sono disposti gli array bidimensionali

"Ora, ricordi la particolarità degli array bidimensionali che hai notato all'inizio della lezione?"

"Sì! Era che gli array bidimensionali sono in realtà array di array!"

"Giusto. "In altre parole, se nel caso di un array ordinario una variabile di array memorizza un riferimento a un contenitore che memorizza elementi di array, allora nel caso di array bidimensionali la situazione esplode un po': un array bidimensionale La variabile -array memorizza un riferimento a un contenitore che memorizza i riferimenti a matrici unidimensionali. È meglio vederlo in azione una volta piuttosto che cercare di spiegarlo cento volte:"

"Sulla sinistra , abbiamo una variabile array bidimensionale, che memorizza un riferimento a un oggetto array bidimensionale. Al centro c'è un oggetto array bidimensionale le cui celle memorizzano array unidimensionali, che sono il righe di un array bidimensionale. E sulla destra , puoi vedere quattro array unidimensionali — le righe del nostro array bidimensionale. Ecco come funzionano effettivamente gli array bidimensionali."

"Fantastico! Ma cosa ci dà?"

"Poiché un 'contenitore di contenitori' memorizza i riferimenti a 'array di righe', possiamo scambiare le righe molto rapidamente e facilmente. Per ottenere un 'contenitore di contenitori', devi solo specificare un indice invece di due. Esempio:

int[][] data = new int[2][5];
int[] row1 = data[0];
int[] row2 = data[1];

"Guarda il codice qui sotto. Possiamo usarlo per scambiare righe:"

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {5, 4, 3, 2, 1}
};

int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;

{
  {5, 4, 3, 2, 1},
  {1, 2, 3, 4, 5}
};

"Ricevuto. Funziona come scambiare due oggetti ordinari qualsiasi."

"Così funziona. Bene, se ti riferisci a una cella di un array bidimensionale, ma specifichi solo un indice dopo il nome dell'array, allora ti riferisci a un contenitore di contenitori le cui celle memorizzano i riferimenti a uno ordinario- matrici dimensionali."

"Sembra tutto logico e chiaro. Grazie per la conferenza, Rishi!"

"Prego. Mettilo in pratica con saggezza."