Array 2D

1. Matrici bidimensionali

Un altro fatto interessante sugli array. Gli array non sono solo unidimensionali (lineari). Possono anche essere bidimensionali.

Cosa significa, chiedi?

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 nome è il nome della variabile matrice, larghezza è la larghezza della tabella (in celle) e altezza è l'altezza della tabella. Esempio:

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

Ecco come apparirà in memoria:

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

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

Ci sono così tanti posti in cui tu, come programmatore, potresti aver bisogno di un array bidimensionale. Gli array bidimensionali sono il fondamento di quasi tutti i giochi da tavolo, ad esempio scacchi, dama, tris e battaglie navali:

Gli array bidimensionali sono perfetti per gli scacchi o la battaglia navale. Abbiamo solo bisogno di numeri dalle coordinate della cella. Non 'pedone e2-e4', ma 'pedone (5,2) -> (5,4)'. Sarà ancora più facile per te come programmatore.

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

A proposito, c'è un dilemma interessante qui:

Quando creiamo un array usando new int[2][5];, abbiamo una tabella di 'due righe e 5 colonne ' o è 'due colonne e 5 righe '?" In altre parole, stiamo specificando prima la larghezza e poi l'altezza... o viceversa, prima l'altezza e poi la larghezza?Beh, come diciamo spesso, qui non è tutto così semplice.

Cominciamo con la domanda su come l'array è memorizzato in memory .

Certo, la memoria del computer non ha effettivamente una matrice al suo interno: ogni locazione in memoria ha un indirizzo numerico sequenziale: 0, 1, 2, ... Nel nostro caso parliamo di una matrice 2 × 5, ma in memoria sono solo 10 celle consecutive, niente di più. Niente indica dove si trovano le righe e le colonne.

Argomento a favore di "larghezza x altezza".

L'argomento a favore di questo approccio è che tutti imparano la matematica a scuola, dove imparano che le coppie di coordinate sono scritte come "x" (cioè l'asse orizzontale) e poi "y" (la dimensione verticale). E questo non è solo uno standard scolastico, è uno standard generalmente accettato in matematica. Come si suol dire, non puoi discutere con la matematica. È così? Prima la larghezza e poi l'altezza?

Argomento a favore di "altezza x larghezza".

C'è anche un argomento interessante da sostenere per questa posizione: inizializzazione rapida di array bidimensionali. Infatti, se vogliamo inizializzare il nostro array, allora possiamo scrivere codice come questo:

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

Non ti accorgi di niente? 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 matrice con 2 righe e 5 colonne.

Linea di fondo

Cosa possiamo dire? Sta a te decidere quale è più conveniente per te. 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, molto probabilmente tutto sarà basato su una rapida inizializzazione dei dati, cioè avrai lo standard "altezza x larghezza".

Se sei abbastanza fortunato da trovarti in un progetto che coinvolge molta matematica e lavora con le coordinate (ad esempio, i motori di gioco), molto probabilmente il codice adotterà l'approccio "larghezza x altezza".

3. Come sono disposti gli array bidimensionali

E ora imparerai come sono effettivamente disposti gli array bidimensionali. Pronto?

Gli array bidimensionali sono in realtà array di array!

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

A sinistra , abbiamo una variabile array bidimensionale, che memorizza un riferimento a un oggetto array bidimensionale. Nelal centro abbiamo un oggetto array bidimensionale le cui celle memorizzano array unidimensionali, che sono le 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. E questo approccio offre al programmatore Java diversi vantaggi:

Innanzitutto , 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];

Questo codice ti consente di scambiare le 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}
};

Se fai riferimento 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 normali array unidimensionali.