Tweedimensionale arrays

1. Tweedimensionale arrays

Nog een interessant feit over arrays. Arrays zijn niet alleen eendimensionaal (lineair). Ze kunnen ook tweedimensionaal zijn.

Wat betekent dat, vraag je?

Dit betekent dat de cellen van de array niet alleen een kolom (of rij) kunnen vertegenwoordigen, maar ook een rechthoekige tabel.

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

Waar naam de naam is van de arrayvariabele, is width de tabelbreedte (in cellen) en height de tabelhoogte. Voorbeeld:

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

Zo ziet het er in het geheugen uit:

Trouwens, je kunt ook snelle initialisatie gebruiken voor tweedimensionale arrays:

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

Er zijn zoveel plaatsen waar je als programmeur misschien een tweedimensionale array nodig hebt. Tweedimensionale reeksen vormen de basis van bijna elk bordspel, bijvoorbeeld schaken, dammen, boter-kaas-en-eieren en zeeslagen:

Tweedimensionale arrays zijn perfect voor schaken of zeeslagen. We hebben alleen getallen nodig uit celcoördinaten. Niet 'pion e2-e4', maar 'pion (5,2) -> (5,4)'. Voor jou als programmeur wordt het nog makkelijker.

2. Elementen rangschikken in arrays: (x, y) of (y, x)

Er is hier trouwens een interessant dilemma:

Als we een array maken met new int[2][5];, hebben we dan een tabel met 'twee rijen en 5 kolommen ' of is het 'twee kolommen en 5 rijen '?" Met andere woorden, specificeren we eerst de breedte en dan de hoogte... of andersom, eerst de hoogte en dan de breedte?Nou, zoals we vaak zeggen, hier is alles niet zo eenvoudig.

Laten we beginnen met de vraag hoe de array in het geheugen wordt opgeslagen .

Natuurlijk bevat het computergeheugen eigenlijk geen matrix: elke locatie in het geheugen heeft een sequentieel numeriek adres: 0, 1, 2, ... In ons geval spreken we van een 2 × 5 matrix, maar dan in het geheugen het zijn slechts 10 opeenvolgende cellen, niets meer. Niets geeft aan waar de rijen en kolommen zijn.

Argumenteer voor "breedte x hoogte".

Het argument voor deze benadering is dat iedereen op school wiskunde leert, waar ze leren dat coördinatenparen worden geschreven als 'x' (dat wil zeggen de horizontale as) en vervolgens 'y' (de verticale dimensie). En dit is niet alleen een schoolstandaard - het is een algemeen aanvaarde standaard in wiskunde. Zoals ze zeggen, met wiskunde valt niet te twisten. Is dat zo? Eerst breedte en dan hoogte?

Argument voor "hoogte x breedte".

Er is ook een interessant argument voor deze positie: snelle initialisatie van tweedimensionale arrays. Als we onze array willen initialiseren, kunnen we inderdaad de volgende code schrijven:

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

Merk je niets? Wat als we dit hebben?

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

Als we onze gegevens regel voor regel in de code schrijven, krijgen we een matrix met 2 rijen en 5 kolommen.

Het komt erop neer

Wat kunnen we zeggen? Het is aan jou om te beslissen wat voor jou handiger is. Het belangrijkste is dat alle programmeurs die aan hetzelfde project werken dezelfde aanpak hanteren.

Als je aan een project werkt waarvan de code veel geïnitialiseerde tweedimensionale arrays bevat, dan zal hoogstwaarschijnlijk alles gebaseerd zijn op snelle data-initialisatie, dwz je hebt de standaard 'hoogte x breedte'.

Als je het geluk hebt om in een project terecht te komen waarbij veel wiskunde komt kijken en werken met coördinaten (bijvoorbeeld game-engines), dan zal de code hoogstwaarschijnlijk de 'breedte x hoogte'-benadering aannemen.

3. Hoe tweedimensionale arrays zijn gerangschikt

En nu leer je hoe tweedimensionale arrays eigenlijk zijn gerangschikt. Klaar?

Tweedimensionale arrays zijn eigenlijk arrays van arrays!

Met andere woorden, als in het geval van een gewone array een arrayvariabele een verwijzing opslaat naar een container die array-elementen opslaat, dan explodeert de situatie in het geval van tweedimensionale arrays een beetje: een tweedimensionale arrayvariabele slaat een verwijzing naar een container die verwijzingen naar eendimensionale arrays opslaat. Het is beter om het een keer in actie te zien in plaats van het honderd keer te proberen uit te leggen:

Aan de linkerkant hebben we een tweedimensionale matrixvariabele, die een verwijzing naar een tweedimensionaal matrixobject opslaat. In demidden hebben we een tweedimensionaal array-object waarvan de cellen eendimensionale arrays opslaan, dit zijn de rijen van een tweedimensionale array. En aan de rechterkant zie je vier eendimensionale arrays — de rijen van onze tweedimensionale array.

Dit is hoe tweedimensionale arrays eigenlijk werken. En deze aanpak geeft de Java-programmeur verschillende voordelen:

Ten eerste , aangezien een 'container met containers' verwijzingen naar 'arrays of rows' opslaat, kunnen we heel snel en gemakkelijk rijen verwisselen. Om een ​​'container met containers' te krijgen, hoeft u slechts één index op te geven in plaats van twee. Voorbeeld:

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

Met deze code kun je rijen verwisselen:

// 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}
};

Als u verwijst naar een cel van een tweedimensionale array, maar u specificeert slechts één index achter de naam van de array, dan verwijst u naar een container met containers waarvan de cellen verwijzingen naar gewone eendimensionale arrays opslaan.