Flerdimensionell array i Java: Placera en array i en array för att skapa en tabell

I den här artikeln så kommer vi lära oss om flerdimensionell, även kallat multidimensionell, array i Java. En flerdimensionell array består av två, eller fler, dimensioner. Vi kommer se vad som menas med flerdimensionell array och hur vi kan använda dem. Avslutningsvis ska vi självklart se en rad olika exempel på hur vi kan arbeta med en flerdimensionell array i Java.

Vad är en flerdimensionell array i Java?

Till att böra med, en flerdimensionell array består av två, eller fler, dimensioner. Vi betraktade tidigare den endimensionella array som en lista som innehöll flera element som kunde ha värden. På samma sätt kan vi se en flerdimensionell array i två dimensioner som en matris med rader och kolumner, likt ett rutnät, bingobräda eller ett schakbräde.

Om vi ska illustrera en flerdimensionell array i två dimensioner på likande sätt som vi gjorde för en endimensionella array skulle vi kunna tänka oss att det ser ut som:

Vidare, vi kan föreställa oss en array med tre dimensioner som ett block, eller en kub, och om vi tar och försöker illustrera den så får vi följande:

Innan vi fortsätter och läser vidare om den flerdimensionell array, se till att du känner till och har koll på den endimensionella array i java.

Varför använda en flerdimensionell array i Java?

I grund och botten används flerdimensionell array om du vill placera en array i en array. Det kan låta komplicerat, men tänk dig att du vill spara ned data i tabellformat, till exempel, testresultatet för eleverna i en klass. Det medför då att vi får fler lagringsplatser att arbeta med och det brukar därför beskrivas som en array av en array, eller fält av fält. Helt enkelt, en flerdimensionell array används för att lagra information i en matrisform, exempelvis. ett schema kan inte realiseras som en endimensionell array.

Hur fungerar en flerdimensionell array i Java?

Likt en endimensionella array så kan vi använda, läsa av och redigera varje element i array med hjälp av index. Om vi tänker oss en tvådimensionella array (den är lättast att föreställa sig) som en matris eller ett rutnät ordnat i rader och kolumner, så kan vi på samma sätt som för en endimensionella array genom att skriva arrayens namn följt av index inom hakparentes läsa av och redigera element.

Om vi tar och illustrerar hur index i en tvådimensionell array ser ut så får en bild enligt den enligt figur 3 nedan, och för att göra det tydligare har vi färgkodat radindex respektive kolumnindex.

Den array vi ritade upp i figur 3 består av tre kolumner och fyra rader vilket ger totalt tolv element.

Hur skapar man en flerdimensionell array i Java?

En flerdimensionell array skapas på liknande sätt som för en endimensionella array, och man kan även här säga att det generellt finns två tillvägagångssätt för att skapa en flerdimensionell array. Vii kommer gå igenom syntax följt av ett kortare exempel för båda, och vi har även här valt att kalla dom för tillvägagångssätt 1 och tillvägagångssätt 2.

Syntax: Deklarera en tvådimensionell array med tillvägagångssätt 1

Om vi börjar med syntax för att deklarera en tvådimensionell array som vi tänker oss som en tabell med rader och kolumner

datatyp[][] namn = new datatyp[antal element(rad)][antal element (kolumn)];

Syntax: Deklarera en tredimensionell array med tillvägagångssätt 1

Vidare, om vi tänker oss ett koordinatsystem med x-, y- och z-led så skapar vi en tredimensionell array enligt.

datatyp[][][]namn= new datatyp[element x-led][element y-led][elemnt z-led];

Avslutningsvis, låt oss ta det stegvis

• Först anger man vilken datatyp array ska bestå av, följt av två hakparentes [ ][ ] för en tvådimensionell array, eller tre hakparentes [ ][ ][ ] för en tredimensionell array
• Sedan ger man ett namn på Array följt av = new datatyp. Datatypen måste vara densamma vid båda tillfällena.
• Avslutningsvis anger man antal element som Array ska innehålla inom hakparentesen för raderna respektive kolumnerna, följt av semikolon.

Exempel: Deklarera en tvådimensionell array i Java med tillvägagångssätt 1

Låt oss ta ett kort exempel för att visa hur det ser ut när man använder det vi kallar tillvägagångssätt 1 för att skapa en tvådimensionell array som har 4 rader och 3 kolumner.

int [][] twoAr = new int [4][3];

Vill vi sedan redigera eller använda ett element i matrisen så gör vi det enkelt på samma sätt som för en endimensionell array. Vi kan börja med att sätta in tre värden i vår tvådimensionella array twoAr.

twoAr[0][2] = 15; 
twoAr[2][1] = 7;
twoAr[3][0] = 22;

Vilket kommer se ut som,

Vidare, om vi sedan vill använda det vi har stoppat in i vår array så skriver vi enkelt

5int sum = twoAr[0][2] + twoAr[2][1]; 
int sumAll = twoAr[0][2] + twoAr[2][1] + twoAr[3][0];
int multi = twoAr[0][2] * twoAr[2][1];

System.out.println(sum);
System.out.println(sumAll);
System.out.println(multi);

Och får då resultatet

22
44
105

Syntax: Deklarera en flerdimensionell array med tillvägagångssätt 2

Vi kan också skapa flerdimensionell array med vad vi kallar som tillvägagångssätt 2 på liknande sätt som vi såg för endimensionella array där vi helt enkelt initierar värden direkt när vi skapar vår array.

datatyp [][] namn = {{ värde, värde, ... },
                     { värde, värde, ... }, 
                     { värde, värde, ... }} ;

Notera att i det här fallet så är det måsvingar, { } , som används till höger om lika-med tecknet.

Exempel: Deklarera en tvådimensionell array i Java med tillvägagångssätt 2

Vi tar ett kort exempel för att visa hur det ser ut när man använder det vi kallar tillvägagångssätt 2

int [][] twoArr2 = {{2, 3},
                      {34, 56},
                      {44, 654, 79},
                      {12, 9, 23, 44}};

Vidare, om vi sedan illustrerar det med en enkel bild

Viktigt att notera att vi inte har skapat en 4 x 4 matris utan att raderna har olika många kolumner. Till exempel, om vi skulle vilja lägga till ett element på index [ 1 ][ 2 ] och skriver

twoArr2[1][2] = 15;

så kommer vi att få java.lang.ArrayIndexOutOfBoundsException. Vi behöver i såna fall skapa en ny array för att kunna lägga till fler index. På nästa sida ska vi lära oss om ArrayList som möjliggör att arbeta med föränderliga samlingar av data.

Exempel: Flerdimensionell array i Java

Vi ska nu se ett par exempel på hur vi kan arbeta med en flerdimensionell array.

Exempel 1: Söka igenom en tvådimensionell array

Vidare, om vi skulle till exempel leta igenom tvådimensionell array så behöver vi använda två for-loopar. På liknande sätt om vi skulle haft en tredimensionell array så hade vi behövt tre for-loopar, alltså en for-loop per dimension kan man säga. Det här kan vara lite knepigt att förstå till en början så vi tar det lugnt och metodiskt.

Vi använder samma tvådimensionella array, twoAr, från föregående exempel där vi sätter in ett par värden.

int [][] twoAr = new int [4][3];
twoAr[0][2] = 15;
twoAr[2][1] = 7;
twoAr[2][2] = 46;
twoAr[3][0] = 22;
twoAr[3][1] = 33;

Som kommer resultera i

Sedan kommer vi använda oss av de två for-looparna och funktionen .length för att ta längden på varje rad och varje kolumn.

for (int row = 0; row < twoAr.length; row++){
     for (int column = 0; column < twoAr[row].length; column++){

     }
}

Okej, låt oss ta det lugnt och metodiskt. Den första for-loopen använder vi för att gå igenom varje rad. Vi kommer då börja på rad 0 eftersom index för en array i Java alltid börja på 0.

for (int row = 0; row < twoAr.length; row++){

Sedan, så lägger vi till den for-loop som kollar varje kolumn i den raden.

for (int column = 0; column < twoAr[row].length; column++){

Det vi gör är alltså att kolla igenom arrayen rad för rad, med andra ord, vi börjar på rad index 0 och kollar alla element där, sen hoppar vi ner till rad index 1, så fortsätter vi så, Om vi tar och skriver ut alla element i vår array twoAr som är skilda från 0 så ser vi tydligt vilken ordning for-loopen går igenom twoAr

for (int row = 0; row < twoAr.length; row++){
     for (int column = 0; column < twoAr[row].length; column++){

     // Kolla så att värdet inte är 0
          if(twoAr[row][column] != 0){
               System.out.println(twoAr[row][column]);
          }
     }
}

Som resulterar i

15
7
46
22
33

Avslutningsvis, det som brukar vara lite knepigt att förstå är twoAr[row].length kommandot, men det den gör är att för varje rad så tar det längden på den raden. I vårt fall så är alla rader lika långa men det en tvådimensionell array kan ha olika långa rader. Vidare, notera att variabeln row är något vi har skapat i for-loopen.

Exempel 2: Hitta största värdet tvådimensionell array i Java

Om vi nu skulle vilja lägga till en funktion i vårt program. Säg att vi vill hitta det största värdet i den tvådimensionella array från föregående exempel och skriva ut värdet plus index vars det hittades

int [][] twoAr = new int [4][3];
twoAr[0][2] = 15;
twoAr[2][1] = 7;
twoAr[2][2] = 46;
twoAr[3][0] = 22;
twoAr[3][1] = 33;

Så gör vi det enkelt med två for-loopar och en if-sats.

int maxVar = twoAr[0][0];
int rowIndex = 0;
int columnIndex = 0;

for (int row = 0; row < twoAr.length; row++){
    for (int column = 0; column < twoAr[row].length; column++){

        if (twoAr[row][column] > maxVar){
            maxVar = twoAr[row][column];
            rowIndex = row;
            columnIndex = column;
            }
        }
}

Avslutningsvis så skrivet vi ut vårt resultat

System.out.println("Value: " + maxVar + " at index " + 
                          rowIndex + ":" + columnIndex);

och får svaret:

Value: 46 at index 2:2

Exempel 3: Söka igenom en tredimensionell array

Vi tar ett tredje och sista exempel där vi ska söka igenom en tredimensionell array. Till vår hjälp kommer vi använda tre stycken for-loopar och det vi ska göra är att skriva ut värdet på varje element med tillhörande index.

Till att börja med så skapar vi en tredimensionell array med ett par värden

int[][][] threeArr = { { { 1, 2, 3 }, { 4, 5, 6 } }, 
                { { 10, 20, 30 }, { 40, 50, 60 } } };

Sedan så initierar vi de tre for-loopar vi använder för att gå igenom alla element i threeArr

for (int i = 0; i < threeArr.length; i++)   {

    for (int j = 0; j < threeArr[i].length; j++)  {
                
        for (int k = 0; k < threeArr[i][j].length; k++) {

          // Skriva ut informationen
          System.out.print("threeArr[" + i + "][" + j + "][" + k + "] = " 
          + threeArr[i][j][k] + "\t");
        }
        // Används enbart för tydligare utskrift
        System.out.println();
    }
    // Används enbart för tydligare utskrift
    System.out.println();
}

Avslutningsvis, resultatet om vi exekverar programmet ovan blir

threeArr[0][0][0] = 1	threeArr[0][0][1] = 2	threeArr[0][0][2] = 3	
threeArr[0][1][0] = 4	threeArr[0][1][1] = 5	threeArr[0][1][2] = 6	

threeArr[1][0][0] = 10	threeArr[1][0][1] = 20	threeArr[1][0][2] = 30	
threeArr[1][1][0] = 40	threeArr[1][1][1] = 50	threeArr[1][1][2] = 60

Sammanfattning av flerdimensionell array i Java

En flerdimensionell array består av två, eller fler, dimensioner. Vi kan likna en tvådimensionell array som en matris eller en tabell, och en tredimensionell array som en kub. En flerdimensionell array brukar beskrivas som en array av en array, och medför att vi får fler lagringsplatser att arbeta med. 

Flerdimensionell array skapas på liknande sätt som för en endimensionella array, och man kan även här säga att det generellt finns två tillvägagångssätt. Exempelvis, syntax för en tvådimensionell array är

datatyp[][] namn = new datatyp[antal element(rad)][antal element (kolumn)];

eller det andra tillvägagångssättet,

datatyp [][] namn = {{ värde, värde, ... },
                     { värde, värde, ... }, 
                     { värde, värde, ... }} ;

Vanliga frågor och svar: Flerdimensionell array i Java