Gekartelde arrays in Java

1. Gekartelde arrays

Als Java-programmeur kun je niet alleen de rijen van een tweedimensionale array verwisselen, maar ook een array samenstellen zoals je wilt.

Stel dat u wilt dat de eerste rij van een tweedimensionale array een lengte heeft van 10, en u wilt dat de lengte van de tweede rij 50. Kunnen we dat doen? Ja dat kunnen we.

Eerst moeten we een 'container met containers' maken - dit is de eerste array, waarin verwijzingen naar arrays van rijen worden opgeslagen. Dit is hoe het gedaan is:

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

U laat gewoon de tweede dimensie weg en de Java-machine maakt een container met containers. Dit is wat er in het geheugen zal zijn na het uitvoeren van deze code:

En, nou, je weet al hoe je eendimensionale arrays maakt 🙂

Zo ziet de resulterende code eruit:

// Matrix of important data
int[][] matrix = new int[2][];
matrix[0] = new int[10];
matrix[1] = new int[50]

We hebben zojuist een zogenaamde " gekartelde array " gemaakt.

En als we nu alle elementen van deze array op het scherm willen tonen, dan lengthkomt de eigenschap van de array goed van pas: de lengtes van de rijen van de array zijn immers verschillend.

Hoe vind je trouwens de lengte van een 'container met containers' in ons voorbeeld? Het is ook een array-object, wat betekent dat het een lengte heeft. Het juiste antwoord is matrix.length.

Hoe zit het met de arrays waaruit onze rijen bestaan?matrix[0].length

2. Werken met een tweedimensionale array

Stel dat u een tweedimensionale matrix wilt weergeven. Hoe doe je dat?

Onze code ziet er ongeveer zo uit:

int[][] matrix = new int[3][];
matrix[0] = new int[]{1, 2, 3, 4, 5, 6};
matrix[1] = new int[]{1, 2, 3};
matrix[2] = new int[]{1};
for (int i = 0; i < matrix.length; i++) {
   for (int j = 0; j < matrix[i].length; j++)
      System.out.print( matrix[i][j] + " " );
   System.out.println();
}

Je hebt twee geneste lussen nodig. De eerste noemen we uiterlijk , en de tweede - innerlijk .

In de buitenste lus (de ivariabele) doorlopen we achtereenvolgens alle rijen (arrays) waaruit onze tweedimensionale array bestaat. Elke waarde van ikomt overeen met een rij met die index.

In de binnenste lus (de jvariabele) doorlopen we alle cellen in de rijen. Dankzij de binnenste lus wordt een rij, die bestaat uit de waarden van één eendimensionale array, op het scherm weergegeven.

Dit is wat er wordt weergegeven:

1 2 3 4 5 6

1 2 3 4 5 6
1 2 3

1 2 3 4 5 6
1 2 3
1

3. Multidimensionale arrays

Nog een interessant feit over arrays, een feit dat je waarschijnlijk al geraden hebt. Als je een tweedimensionale array kunt maken, kun je dan een driedimensionale array maken?

Ja, u kunt een array van elke dimensie maken. Dergelijke arrays worden 'multidimensionaal' genoemd.

Laten we voor de lol een multidimensionale array maken met 4 dimensies.

 int[][][][] matrix = new int[2][3][4][5];

Deze code is te simpel, nietwaar?

Wat als u het handmatig maakt?

int[][][][] matrix;
matrix = new int[2][][][];                // Create a 2-element array of references to references to references
for (int i = 0; i < matrix.length; i++)
{
  matrix[i] = new int[3][][];                // Create a 3-element array of references to references
  for (j = 0; j < matrix[i].length; j++)
  {
    matrix[i][j] = new int[4][];             // Create a 4-element array of references
    for (k = 0; k < matrix[i][j].length; k++)
      matrix[i][j][k] = new int[5];          // Create 5-element arrays of integers
  }
}

En dat is gewoon het maken van de array! Dan moet je er ook op de een of andere manier mee werken.

Bonustaak: schrijf code die alle waarden weergeeft in een driedimensionale array.