Tvådimensionella arrayer

1. Tvådimensionella arrayer

Ytterligare ett intressant faktum om arrayer. Matriser är inte bara endimensionella (linjära). De kan också vara tvådimensionella.

Vad betyder det, frågar du dig?

Detta innebär att cellerna i arrayen inte bara kan representera en kolumn (eller rad), utan också en rektangulär tabell.

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

Där namn är namnet på arrayvariabeln, bredd är tabellbredden (i celler) och höjd är tabellhöjden. Exempel:

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

Så här kommer det att se ut i minnet:

Förresten, du kan också använda snabb initiering för tvådimensionella arrayer:

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

Det finns så många ställen där du som programmerare kan behöva en tvådimensionell array. Tvådimensionella arrayer är grunden för nästan alla brädspel, t.ex. schack, dam, tic-tac-toe och sjöstrid:

Tvådimensionella arrayer är perfekta för schack eller sjöstrid. Vi behöver bara siffror från cellkoordinater. Inte 'bonde e2-e4', utan 'bonde (5,2) -> (5,4)'. Det blir ännu enklare för dig som programmerare.

2. Ordna element i arrayer: (x, y) eller (y, x)

Förresten, det finns ett intressant dilemma här:

När vi skapar en array med hjälp av new int[2][5];, har vi en tabell med 'två rader och 5 kolumner ' eller är det 'två kolumner och 5 rader '?" Med andra ord, anger vi först bredden och sedan höjden... eller vice versa, först höjden och sedan bredden?Tja, som vi ofta säger, allt är inte så enkelt här.

Låt oss börja med frågan om hur arrayen lagras i minnet .

Naturligtvis har datorminne faktiskt ingen matris i sig: varje plats i minnet har en sekventiell numerisk adress: 0, 1, 2, ... I vårt fall talar vi om en 2 × 5 matris, men i minnet det är bara 10 på varandra följande celler, inget mer. Ingenting indikerar var raderna och kolumnerna finns.

Argument för "bredd x höjd".

Argumentet för detta tillvägagångssätt är att alla lär sig matematik i skolan, där de lär sig att koordinatpar skrivs som 'x' (det vill säga den horisontella axeln) och sedan 'y' (den vertikala dimensionen). Och detta är inte bara en skolstandard – det är en allmänt accepterad standard inom matematik. Som de säger, du kan inte argumentera med matematik. Är det så? Först bredd och sedan höjd?

Argument för "höjd x bredd".

Det finns också ett intressant argument för denna position: snabb initiering av tvådimensionella arrayer. Faktum är att om vi vill initiera vår array kan vi skriva kod så här:

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

Märker du ingenting? Tänk om vi har det här?

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

Om vi ​​skriver våra data i koden rad för rad får vi en matris med 2 rader och 5 kolumner.

Slutsats

Vad kan vi säga? Det är upp till dig att bestämma vilket som är bekvämast för dig. Det viktigaste är att alla programmerare som arbetar med samma projekt håller sig till samma tillvägagångssätt.

Om du arbetar med ett projekt vars kod har massor av initierade tvådimensionella arrayer, så kommer allt troligen att baseras på snabb datainitiering, dvs du kommer att ha standarden 'höjd x bredd'.

Om du har turen att hitta dig själv i ett projekt som involverar mycket matematik och arbetar med koordinater (till exempel spelmotorer), så kommer koden med största sannolikhet att anta metoden "bredd x höjd".

3. Hur tvådimensionella arrayer är arrangerade

Och nu kommer du att lära dig hur tvådimensionella arrayer faktiskt är ordnade. Redo?

Tvådimensionella arrayer är faktiskt arrayer av arrayer!

Med andra ord, om i fallet med en vanlig array en arrayvariabel lagrar en referens till en behållare som lagrar arrayelement, då exploderar situationen lite i fallet med tvådimensionella arrayer: en tvådimensionell arrayvariabel lagrar en referens till en behållare som lagrar referenser till endimensionella arrayer. Det är bättre att se det i aktion en gång istället för att försöka förklara det hundra gånger:

Till vänster har vi en tvådimensionell arrayvariabel, som lagrar en referens till ett tvådimensionellt arrayobjekt. I denmitten har vi ett tvådimensionellt arrayobjekt vars celler lagrar endimensionella arrayer, som är raderna i en tvådimensionell array. Och till höger kan du se fyra endimensionella arrayer - raderna i vår tvådimensionella array.

Så här fungerar tvådimensionella arrayer faktiskt. Och detta tillvägagångssätt ger Java-programmeraren flera fördelar:

För det första , eftersom en "container of containers" lagrar referenser till "arrays of rows", kan vi mycket snabbt och enkelt byta rader. För att få en 'container of containers' behöver du bara ange ett index istället för två. Exempel:

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

Denna kod låter dig byta rader:

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

Om du hänvisar till en cell i en tvådimensionell array, men du bara anger ett index efter namnet på arrayen, hänvisar du till en behållare med behållare vars celler lagrar referenser till vanliga endimensionella arrayer.