Sobald du in Java nicht mehr nur eine einfache Liste von Werten brauchst, landest du schnell bei Arrays mit mehreren Dimensionen. Genau an der Stelle wird es für viele unübersichtlich. Ein normales Array ist noch leicht zu greifen: mehrere Werte hintereinander in einer Reihe. Ein multidimensionales Array erweitert genau diese Idee. Du hast dann nicht nur eine Reihe, sondern mehrere Reihen, Ebenen oder noch mehr Schichten.

Das klingt erstmal deutlich komplizierter, als es eigentlich ist. Der wichtigste Schritt ist deshalb nicht, dir sofort jede Klammer zu merken, sondern ein sauberes Bild im Kopf aufzubauen. Wenn das sitzt, wird auch der Code deutlich verständlicher.

 

Was ein multidimensionales Array eigentlich ist

Ein eindimensionales Array kennst du wahrscheinlich schon. Das sieht zum Beispiel so aus:

int[] zahlen = {3, 7, 12, 19};

Hier liegen vier Werte in genau einer Reihe. Du greifst mit einem Index darauf zu. zahlen[0] ist 3, zahlen[1] ist 7 und so weiter.

Ein zweidimensionales Array ist im Grunde ein Array, das weitere Arrays enthält. In Java ist das ein wichtiger Punkt, denn technisch gesehen hast du also kein magisches Spezialkonstrukt, sondern ein Array von Arrays.

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

Du kannst dir das wie ein Raster vorstellen. Die erste Klammer wählt die Zeile aus, die zweite Klammer die Position innerhalb dieser Zeile. matrix[0][0] ist also 1. matrix[1][2] ist 6.

Bis hierhin hilft meistens dieses Bild: Die erste Dimension sagt dir, in welches innere Array du gehst. Die zweite Dimension sagt dir, welchen Wert du darin nimmst.

Genau das gleiche Prinzip geht weiter. Ein dreidimensionales Array ist ein Array aus zweidimensionalen Arrays. Und ein vierdimensionales Array ist wieder eine Ebene mehr. Die Syntax wächst also nur weiter, aber die eigentliche Idee bleibt gleich: Du gehst Schicht für Schicht tiefer.

 

Zweidimensionale Arrays wirklich verstehen

Mit zwei Dimensionen lässt sich das Thema am einfachsten sauber lernen. Deshalb lohnt es sich, hier kurz langsam zu bleiben. Stell dir ein Spielfeld vor, zum Beispiel drei Zeilen und vier Spalten:

int[][] feld = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

Wenn du feld[0] schreibst, bekommst du nicht direkt eine Zahl zurück, sondern die komplette erste Zeile. Das Ergebnis ist also das Array {1, 2, 3, 4}. Erst mit feld[0][2] landest du beim einzelnen Wert 3.

Das ist der Punkt, an dem viele Fehler passieren. Die erste Klammer springt nicht direkt zum endgültigen Wert, sondern erstmal nur in das nächste innere Array.

Du kannst ein zweidimensionales Array auch leer anlegen und später befüllen:

int[][] punkte = new int[2][3];

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

new int[2][3] bedeutet hier: zwei Zeilen, drei Spalten. Java füllt neue int-Arrays automatisch mit 0.

Oft willst du so ein Array komplett durchlaufen. Dafür brauchst du verschachtelte Schleifen. Die äußere Schleife geht die Zeilen durch, die innere Schleife die Spalten.

for (int zeile = 0; zeile < punkte.length; zeile++) {
    for (int spalte = 0; spalte < punkte[zeile].length; spalte++) {
        System.out.println("Wert: " + punkte[zeile][spalte]);
    }
}

Auch hier ist das Denken wieder wichtiger als die Syntax. Erst nimmst du eine Zeile, dann arbeitest du innerhalb dieser Zeile die einzelnen Werte ab.

Spannend wird es in Java noch an einer anderen Stelle: Nicht jede Zeile muss gleich lang sein. Weil ein zweidimensionales Array eben ein Array aus Arrays ist, kann jede innere Zeile unterschiedlich viele Elemente haben.

int[][] ungleich = {
    {1, 2},
    {3, 4, 5},
    {6}
};

Das ist fachlich korrekt und völlig erlaubt. Deshalb ist ungleich[zeile].length in Schleifen so wichtig. Wenn du stattdessen stur von einer festen Spaltenanzahl ausgehst, läufst du schnell in einen ArrayIndexOutOfBoundsException.

 

Drei oder mehr Dimensionen ohne Knoten im Kopf

Sobald eine dritte Dimension dazukommt, solltest du nicht mehr versuchen, alles gleichzeitig als großes Monster zu sehen. Zerlege es lieber bewusst in Ebenen. Genau das macht den Unterschied.

Ein dreidimensionales Array kannst du dir wie mehrere zweidimensionale Felder vorstellen. Also nicht nur ein Raster, sondern mehrere Raster übereinander oder nebeneinander.

int[][][] lager = {
    {
        {10, 20},
        {30, 40}
    },
    {
        {50, 60},
        {70, 80}
    }
};

Dieses Beispiel hat drei Schichten. Die erste Dimension wählt den Block. Die zweite Dimension wählt die Zeile in diesem Block. Die dritte Dimension wählt den Wert in dieser Zeile.

Wenn du lager[0] schreibst, bekommst du den ersten kompletten Block zurück:

{
    {10, 20},
    {30, 40}
}

Mit lager[0][1] gehst du in diesem Block in die zweite Zeile:

{30, 40}

Und mit lager[0][1][0] landest du schließlich beim einzelnen Wert 30.

Ein paar direkte Zugriffe machen das meist schneller verständlich:

System.out.println(lager[0][0][0]); // 10
System.out.println(lager[0][1][1]); // 40
System.out.println(lager[1][0][1]); // 60
System.out.println(lager[1][1][0]); // 70

Lies solche Zugriffe immer von links nach rechts. Erst der Block, dann die Zeile, dann die Spalte. Genau so behältst du die Kontrolle.

Für ein vierdimensionales Array gilt exakt dieselbe Regel. Du hast einfach noch eine Schicht mehr davor. Statt direkt Block, Zeile, Spalte kommt zuerst noch eine äußere Ebene dazu.

int[][][][] daten = {
    {
        {
            {1, 2},
            {3, 4}
        },
        {
            {5, 6},
            {7, 8}
        }
    },
    {
        {
            {9, 10},
            {11, 12}
        },
        {
            {13, 14},
            {15, 16}
        }
    }
};

Hier gehst du also vier Schritte tief. Ein Zugriff wie daten[1][0][1][1] sieht erstmal wild aus, ist aber nur eine Kette aus vier Entscheidungen.

Wenn wir das sauber zerlegen, wird es deutlich einfacher. daten[1] nimmt den zweiten großen Außenblock. daten[1][0] nimmt darin den ersten inneren Block. daten[1][0][1] nimmt darin die zweite Zeile. daten[1][0][1][1] nimmt darin schließlich den zweiten Wert. Das Ergebnis ist 12.

Auch hier helfen wieder ein paar direkte Beispiele:

System.out.println(daten[0][0][0][0]); // 1
System.out.println(daten[0][1][1][0]); // 7
System.out.println(daten[1][0][1][1]); // 12
System.out.println(daten[1][1][0][1]); // 14

Wenn du bei vier Dimensionen den Überblick verlierst, dann ist das kein Zeichen dafür, dass du das Thema nicht verstehst. Es zeigt nur, dass sehr viele Ebenen gleichzeitig im Spiel sind. Genau deshalb solltest du bei jedem Zugriff bewusst mitsprechen, was jede Klammer gerade auswählt.

Ein weiterer hilfreicher Blick ist dieser: Bei zwei Dimensionen wählst du Zeile und Spalte. Bei drei Dimensionen wählst du zuerst noch einen Block. Bei vier Dimensionen kommt noch ein äußerer Bereich dazu. Die Regel ändert sich nie. Es kommen nur weitere Ebenen davor.

Wenn du solche Arrays komplett durchlaufen willst, brauchst du für jede Dimension genau eine Schleife. Bei drei Dimensionen sind das drei verschachtelte Schleifen. Bei vier Dimensionen entsprechend vier.

for (int a = 0; a < daten.length; a++) {
    for (int b = 0; b < daten[a].length; b++) {
        for (int c = 0; c < daten[a][b].length; c++) {
            for (int d = 0; d < daten[a][b][c].length; d++) {
                System.out.println(daten[a][b][c][d]);
            }
        }
    }
}

Fachlich ist das völlig korrekt. In der Praxis merkst du hier aber auch schnell, warum Arrays mit vielen Dimensionen schwer lesbar werden. Nicht weil Java etwas Komisches macht, sondern weil du als Mensch immer mehr Ebenen gleichzeitig gedanklich sauber halten musst.

Genau deshalb lohnt sich bei echten Projekten oft die Frage, ob eine kleine Klasse mit klar benannten Feldern verständlicher wäre. Zum Lernen sind solche Beispiele aber ideal, weil du daran sehr gut siehst, wie multidimensionale Arrays wirklich aufgebaut sind.

Multidimensionale Arrays wirken am Anfang kompliziert, weil sie viele Klammern und viele Ebenen mitbringen. Die eigentliche Grundidee ist aber überraschend klein. Ein multidimensionales Array ist immer nur ein Array, das weitere Arrays enthält. Du gehst also Schritt für Schritt tiefer hinein, bis du beim gesuchten Wert ankommst.

Wenn du dir bei zweidimensionalen Arrays sauber klarmachst, dass die erste Klammer eine Zeile und die zweite Klammer einen Wert in dieser Zeile auswählt, hast du schon das wichtigste Fundament gelegt. Ab drei Dimensionen ändert sich nicht die Regel, sondern nur die Anzahl der Ebenen. Genau deshalb hilft es, den Zugriff immer langsam von links nach rechts zu lesen.

Wenn dir das Thema schwerfällt, ist das völlig normal. Multidimensionale Arrays sind kein Stoff, den man einmal liest und sofort intuitiv beherrscht. Nimm dir kleine Beispiele, greif gezielt auf einzelne Werte zu und lauf die Struktur mit Schleifen durch. Je öfter du das machst, desto schneller verschwinden die vielen Klammern aus dem Weg und du siehst nur noch die Struktur dahinter.