Tweedimensionale arrays

Een fragment uit een lezing met een mentor als onderdeel van de Codegym University-cursus. Schrijf je in voor de volledige cursus.

"Gegroet, Amigo!"

"Hallo Rishi!"

"Je weet al het een en ander over arrays, en je bent er zelfs in geslaagd om enkele taken op te lossen, hoop ik. Maar je weet niet alles. Hier is bijvoorbeeld nog een interessant feit over arrays. Arrays zijn niet alleen eendimensionaal (lineair ). Ze kunnen ook tweedimensionaal zijn."

"Eh... Wat betekent dat?"

"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 is de tabelhoogte. Bekijk een voorbeeld:

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

"Dit is hoe het eruit zal zien in het geheugen:

"Trouwens, voor tweedimensionale arrays kun je ook snelle initialisatie gebruiken:

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

"Hmm... dat is nu interessant. Als we ons voorstellen dat in de eerste binnenste haakjes één element staat, is het volgende een tweede... Dus een tweedimensionale array is als een array van arrays?"

"Wat ben jij een slimme leerling! Precies. Het eerste element is de eendimensionale array {31, 28, 31}, het tweede is {30, 31, 30}, enzovoort. Maar daar komen we later in deze les op terug. Probeer tot die tijd te denken aan een tweedimensionale matrix als een tabel met rijen en kolommen, die cellen vormen op elke kruising.

'Daar heb ik een mentaal beeld van. Trouwens, waar worden ze voor gebruikt, deze tweedimensionale arrays?'

"Programmeurs hebben vrij vaak tweedimensionale arrays nodig. Als je goed kijkt, wordt bijna elk bordspel geïmplementeerd met behulp van een kant-en-klare tweedimensionale array: schaken, dammen, boter-kaas-en-eieren, zeeslag, enz.:"

"Ik snap het! Het speelveld van schaken of zeeslagen past perfect op tweedimensionale arrays!"

"Ja, maar je moet getallen gebruiken als celcoördinaten. Niet 'pion e2-e4', maar 'pion (5,2) -> (5,4)'. Het wordt voor jou als programmeur nog makkelijker. "

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

"Het maken van tweedimensionale arrays roept een interessant dilemma op. 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, het is niet helemaal duidelijk of we eerst de breedte specificeren en dan de 'hoogte... of andersom, eerst de hoogte en dan de breedte?"

"Ja, dit is het dilemma. En er is geen definitief antwoord."

"Wat moeten we doen?"

"Ten eerste is het belangrijk om te begrijpen hoe onze tweedimensionale array daadwerkelijk in het geheugen wordt opgeslagen . Natuurlijk bevat het computergeheugen eigenlijk geen tabellen: elke locatie in het geheugen heeft een opeenvolgend numeriek adres: 0, 1, 2, ... Voor ons is dit een tabel van 2 × 5, maar in het geheugen zijn het slechts 10 cellen, niets meer. Geen opdeling in rijen en kolommen.'

"Dat begreep ik. Hoe bepalen we dan welke dimensie eerst komt - de breedte of de hoogte?"

"Laten we de eerste optie bekijken. Eerst de breedte, dan de hoogte. "Het argument voor deze benadering is dit: iedereen leert wiskunde op school en ze leren dat coördinatenparen worden geschreven als 'x' (dat wil zeggen, de horizontale as) en dan '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? Nou, als we er niet tegen kunnen, dan eerst de breedte en dan de hoogte?'

"Er is een interessant argument voor 'eerst de hoogte, dan de breedte' . Dit argument komt voort uit de snelle initialisatie van tweedimensionale arrays. Immers, als we onze array willen initialiseren, dan schrijven we code als volgt:"

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

"Dus wat doet dat voor ons?"

"Heb je iets gemerkt? 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 tabel met 2 rijen en 5 kolommen."

"Nu begrijp ik het. 2 is de hoogte en 5 is de breedte... Welke optie moeten we dan gebruiken?"

"Het is aan jou om te beslissen wat 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 daar gebaseerd zijn op snelle data-initialisatie, dat wil zeggen dat je de standaard 'hoogte x breedte' hebt.

"Als je je in een project bevindt waarbij veel wiskunde komt kijken en je met coördinaten werkt (bijvoorbeeld game-engines), dan zal de code hoogstwaarschijnlijk de 'breedte x hoogte'-benadering aannemen.

Hoe tweedimensionale arrays zijn gerangschikt

"Herinner je je nu de speciale eigenschap van tweedimensionale arrays die je aan het begin van de les opmerkte?"

"Ja! Het was dat tweedimensionale arrays eigenlijk arrays van arrays zijn!"

"Heel goed. "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 -array variabele slaat een verwijzing op 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 uit te leggen:"

"Aan de linkerkant hebben we een tweedimensionale array-variabele, die een verwijzing naar een tweedimensionaal array-object opslaat. In het midden is er een tweedimensionaal array-object waarvan de cellen eendimensionale arrays opslaan, die 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 echt werken."

"Fantastisch! Maar wat levert het ons op?"

"Omdat een 'container met containers' verwijzingen naar 'arrays met rijen' 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];

"Kijk naar de onderstaande code. We kunnen deze gebruiken om rijen te 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}
};

"Begrepen. Het werkt als het verwisselen van twee gewone items."

"Dat klopt. Nou, als je verwijst naar een cel van een tweedimensionale array, maar je specificeert slechts één index achter de naam van de array, dan verwijs je naar een container met containers waarvan de cellen verwijzingen opslaan naar gewone een- dimensionale arrays."

"Alles lijkt logisch en duidelijk. Bedankt voor de lezing, Rishi!"

"Graag gedaan. Breng het verstandig in de praktijk."