Mehrdimensionale Arrays

Einführung

Stell dir vor, du möchtest Sitzplätze in einem Kino digital verwalten. Jeder Platz hat eine eindeutige Kombination aus Reihe und Sitznummer. Mit einer einfachen Liste könntest du nur die Sitznummern speichern – doch wie unterscheidest du dann, ob es sich um Platz 5 in Reihe 1 oder Platz 5 in Reihe 7 handelt?

Genau hier stoßen eindimensionale Arrays an ihre Grenzen. Um Daten übersichtlich in Zeilen und Spalten darzustellen, brauchst du eine Struktur, die mehr Informationen gleichzeitig abbilden kann.

Die Lösung sind mehrdimensionale Arrays. Sie ermöglichen dir, Tabellen, Gitter oder sogar räumliche Datenstrukturen direkt in deinem Programm abzubilden.

Lernziele

Nach dieser Einheit kannst du:

• Eindimensionale Arrays deklarieren, initialisieren und nutzen, indem du sicher mit 0-basierten Indizes arbeitest.
• Zweidimensionale Arrays korrekt einsetzen, tabellarische Daten modellieren und mit verschachtelten Schleifen verarbeiten.
• Jagged Arrays anwenden, unterschiedliche Zeilenlängen definieren und deren Vorteile für Speicher und Flexibilität erläutern.
• Zwischen Arrays und Listen unterscheiden, indem du den passenden Einsatz bei fixer oder variabler Datenmenge begründest.

Wozu brauchen wir überhaupt Arrays? Eine kurze Wiederholung

Wir wollen eine Liste von Werten speichern, zum Beispiel die Lottozahlen der letzten Ziehung. Du könntest für jede Zahl eine eigene Variable anlegen:

int zahl1 = 5;
int zahl2 = 12;
int zahl3 = 23;
//... und so weiter

Das wird schnell unübersichtlich und unpraktisch. Genau hierfür gibt es Arrays. Ein Array ist wie ein Regal mit nummerierten Fächern. Du kannst darin mehrere Werte vom selben Typ (z. B. nur Zahlen oder nur Text) an einem Ort speichern. Jedes “Fach” hat eine Nummer, den sogenannten Index, mit dem du direkt darauf zugreifen kannst. Wichtig: Der erste Index ist immer die 0!

// Ein Regal (Array) für 6 Lottozahlen
int[] lottozahlen = {5, 12, 23, 34, 40, 42};
 
// Zugriff auf die erste Zahl (Index 0)
int ersteZahl = lottozahlen[0]; // Das Ergebnis ist 5
 
// Zugriff auf die dritte Zahl (Index 2)
int dritteZahl = lottozahlen[2]; // Das Ergebnis ist 23

Dieses “Regal” ist eine gerade Linie – es hat nur eine Dimension. Man nennt es daher eindimensionales Array. Es ist perfekt für einfache Listen.

Warum eine Dimension manchmal nicht ausreicht

Was passiert aber, wenn unsere Daten eine komplexere Struktur haben? Eindimensionale Listen stoßen schnell an ihre Grenzen. Denk an diese Beispiele:

• Ein Schachbrett: Es ist ein Feld aus 8 Zeilen und 8 Spalten. Um die Position einer Figur zu beschreiben, brauchst du zwei Informationen: die Zeile und die Spalte.
• Eine Kinobestuhlung: Um einen Sitzplatz zu finden, brauchst du auch zwei Angaben: die Reihe und die Sitznummer in dieser Reihe.
• Eine Excel-Tabelle: Daten sind hier fast immer in Zeilen und Spalten organisiert, z. B. eine Liste von Schülern (Zeilen) mit ihren Noten in verschiedenen Fächern (Spalten).

Man könnte versuchen, so etwas in eine lange, eindimensionale Liste zu quetschen, aber das wäre extrem kompliziert und fehleranfällig. Der Code wäre schwer zu lesen und würde die eigentliche Logik des Problems verschleiern.

Die Lösung sind mehrdimensionale Arrays. Sie erlauben uns, Daten so zu speichern, wie sie natürlich strukturiert sind – als Tabelle, Gitter oder sogar als räumlicher Körper.

Das zweidimensionale Array (2D-Array)

Die einfachste Art, sich ein 2D-Array vorzustellen, ist als Tabelle mit Zeilen und Spalten. Technisch gesehen ist es ein “Array von Arrays”: Du hast ein äußeres Array (das “Regal”), aber in jedem Fach liegt nicht nur ein einzelner Wert, sondern ein weiteres, komplettes Array (eine ganze “Regalreihe”).

• Analogie “Tabelle”: Das äußere Array enthält alle Zeilen. Jedes innere Array ist eine einzelne Zeile mit all ihren Spaltenwerten.
• Analogie “Koordinatensystem”: Wie beim Spiel “Schiffe versenken” hat jede Zelle eine eindeutige Position, die durch zwei Koordinaten bestimmt wird: eine für die Zeile und eine für die Spalte.

2D-Arrays erstellen: Deklaration

Ein 2D-Array zu erstellen, ist ganz ähnlich wie bei einem 1D-Array, nur dass wir zwei eckige Klammerpaare [][] verwenden – eines für die Zeilen, eines für die Spalten.

Schritt 1: Deklaration (Die Variable anlegen) Zuerst sagen wir Java, dass wir eine Variable haben möchten, die auf ein 2D-Array zeigen wird.

// Eine Variable für eine Tabelle (Matrix) aus Ganzzahlen
int[][] matrix;
 
// Eine Variable für eine Tabelle aus Texten (Strings)
String[][] tabelle;

Zu diesem Zeitpunkt existiert die Tabelle noch nicht im Speicher. Die Variablen sind leer (sie haben den Wert null).

2D-Arrays erstellen: Initialisierung

Schritt 2: Initialisierung (Die Tabelle im Speicher erzeugen) Jetzt erzeugen wir die eigentliche Tabelle mit dem new-Schlüsselwort.

Möglichkeit A: Mit fester Größe (Die häufigste Methode) Wenn du genau weißt, wie viele Zeilen und Spalten du brauchst.

// Erzeuge eine Tabelle mit 3 Zeilen und 4 Spalten
matrix = new int[3][4];
 
// Deklaration und Initialisierung in einer Zeile
String[][] namen = new String[5][2]; // 5 Zeilen, 2 Spalten

Java füllt diese Tabelle automatisch mit Standardwerten: 0 für Zahlen, false für boolean und null für Objekte wie String. Das Ergebnis ist eine saubere, rechteckige Tabelle.

Möglichkeit B: Direkt mit Werten füllen Wenn du die Werte schon kennst, kannst du sie direkt in geschweiften Klammern angeben.

// Eine 2x3 Tabelle, direkt mit Werten gefüllt
int[][] zahlen = {
    {1, 2, 3}, // Das ist die erste Zeile (Index 0)
    {4, 5, 6}  // Das ist die zweite Zeile (Index 1)
};

Die Größe wird hier automatisch erkannt. Das ist super für kleine, feste Datenmengen wie ein Spielfeld.

Zugriff auf Elemente: Zeile und Spalte angeben

Um einen Wert in der Tabelle zu lesen oder zu ändern, brauchst du immer zwei Indizes: zuerst den Zeilenindex, dann den Spaltenindex.

Die Syntax lautet: arrayName[zeilenIndex][spaltenIndex]

Ganz wichtig: Die Zählung beginnt immer bei Null

• Die erste Zeile hat den Index 0.
• Die erste Spalte hat den Index 0.

Schauen wir uns unsere zahlen-Tabelle an: { {1, 2, 3}, {4, 5, 6} }

// Auf die Zahl 6 zugreifen:
// Sie ist in der zweiten Zeile (Index 1) und der dritten Spalte (Index 2)
int wert = zahlen[1][2]; // wert ist jetzt 6
 
// Den Wert in der ersten Zeile, ersten Spalte ändern:
zahlen[0][0] = 99; // Die Tabelle sieht jetzt so aus: { {99, 2, 3}, {4, 5, 6} }

Ein typischer Anfängerfehler ist der Zugriff auf einen Index, den es nicht gibt (z.B. zahlen[2] oder zahlen[0][3]). Das führt zu einem Programmabsturz mit einer ArrayIndexOutOfBoundsException, da es die dritte Zeile (Index 2) oder die vierte Spalte (Index 3) nicht gibt.

Alle Elemente durchlaufen: Die geschachtelte Schleife

Um die ganze Tabelle zu verarbeiten (z.B. alles auszugeben), brauchen wir zwei for-Schleifen, die ineinander verschachtelt sind.

• Die äußere Schleife kümmert sich um die Zeilen.
• Die innere Schleife kümmert sich um die Spalten innerhalb der aktuellen Zeile.

int[][] matrix = { // int[][] für ein 2D-Array
{10, 20, 30},
{40, 50, 60},
{70, 80, 90}
};
 
// Äußere Schleife: Läuft von Zeile 0 bis zur letzten Zeile
for (int i = 0; i < matrix.length; i++) {
// Innere Schleife: Läuft für jede Zeile von Spalte 0 bis zur letzten Spalte
for (int j = 0; j < matrix[i].length; j++) {
// Gib das Element an der aktuellen Position (i, j) aus
System.out.print(matrix[i][j] + " ");
}
// Nach jeder Zeile machen wir einen Zeilenumbruch für eine schöne Ausgabe
System.out.println();
}

Wichtige Helfer:

• matrix.length: Gibt dir die Anzahl der Zeilen (im Beispiel: 3).
• matrix[i].length: Gibt dir die Anzahl der Spalten in Zeile i (im Beispiel: 3).

⏳ Lädt Dataview-Inhalt...

Jagged Arrays

Bisher waren unsere Tabellen immer schön rechteckig. Aber was, wenn nicht jede Zeile gleich viele Spalten hat? Stell dir vor, du willst die Aufgaben für jeden Wochentag speichern. Am Montag hast du 5 Aufgaben, am Dienstag nur 2.

Hierfür gibt es Jagged Arrays (gestaffelte Arrays). Das sind 2D-Arrays, bei denen jede Zeile eine andere Länge haben kann.

1. Deklaration des 2D-Arrays für 3 Tage (die Zeilen).

// Die Spaltenanzahl lassen wir bewusst offen.
String[][] wochenplan = new String[3][];

2. Initialisierung jeder Zeile mit ihrer individuellen Länge (Anzahl der Aufgaben).

wochenplan[0] = new String[5]; // Montag hat 5 Aufgaben
wochenplan[1] = new String[2]; // Dienstag hat 2 Aufgaben
wochenplan[2] = new String[3]; // Mittwoch hat 3 Aufgaben

3. Zuweisung von Werten zu den einzelnen Aufgaben.

// Aufgaben für Montag (Index 0)
wochenplan[0][0] = "E-Mails checken";
wochenplan[0][1] = "Team-Meeting vorbereiten";
wochenplan[0][2] = "Programmieren";
wochenplan[0][3] = "Code-Review";
wochenplan[0][4] = "Dokumentation schreiben";

Aufgaben für Dienstag (Index 1)

wochenplan[1][0] = "Meeting mit Kunde";
wochenplan[1][1] = "Präsentation erstellen";

Aufgaben für Mittwoch (Index 2)

wochenplan[2][0] = "Fehleranalyse";
wochenplan[2][1] = "Tests durchführen";
wochenplan[2][2] = "Deployment planen";

Ausgabe der ersten Aufgabe am Montag

System.out.println(wochenplan[0][0]); // Gibt aus: E-Mails checken

Der große Vorteil ist die Speichereffizienz: Es wird nur so viel Platz belegt, wie wirklich gebraucht wird.

3D-Arrays und der Blick darüber hinaus

Ein wichtiger Hinweis für deine Ausbildung und die Prüfung:
In den meisten Fällen, besonders in Prüfungsaufgaben, wirst du auf zweidimensionale Arrays treffen. Das Verständnis von 3D-Arrays ist allerdings gut für das Gesamtbild und zeigt ein tieferes Verständnis

Das Konzept: Ein Stapel von Tabellen

Wenn ein 2D-Array eine Tabelle ist, was ist dann ein 3D-Array? Ganz einfach: ein Stapel von Tabellen oder ein “Array von 2D-Arrays”.

• Analogie “Würfel”: Stell dir einen Würfel vor, der aus vielen kleinen Würfeln besteht. Um einen kleinen Würfel zu finden, brauchst du drei Koordinaten: Ebene (oder Tiefe), Zeile und Spalte.
• Analogie “Buch”: Ein Buch ist ein Stapel von Seiten. Jede Seite ist eine 2D-Fläche mit Zeilen und Spalten. Der erste Index wählt die Seite aus, die anderen beiden die Position auf der Seite.

Syntax und Anwendungsfälle

Die Syntax wird einfach um eine weitere Dimension erweitert:

// Ein 3D-Array mit 2 Ebenen, 3 Zeilen und 4 Spalten
int[][][] quader = new int[2][3][4];
 
// Zugriff auf ein Element in
// Ebene 0, Zeile 1, Spalte 2
quader[0][1][2] = 100;
 
// Iteration braucht drei geschachtelte Schleifen
for (int ebene = 0; ebene < quader.length; ebene++) {
    for (int zeile = 0; zeile < quader[ebene].length; zeile++) {
        for (int spalte = 0; spalte < quader[ebene][zeile].length; spalte++) {
            //... Element verarbeiten...
        }
    }
}

Wo braucht man das?

• Computergrafik: Um 3D-Welten wie in Minecraft aus Voxeln (3D-Pixeln) aufzubauen.
• Bildverarbeitung: Ein Farbbild ist oft ein 3D-Array: Die ersten beiden Dimensionen sind Höhe und Breite, die dritte Dimension speichert die Farbkanäle (z.B. 0=Rot, 1=Grün, 2=Blau).
• Medizinische Daten: Ein CT-Scan besteht aus vielen 2D-Bild-Schnitten, die man perfekt in einem 3D-Array stapeln kann.

Theoretisch kann man das beliebig fortsetzen (4D, 5D,…), aber in der Praxis sind Arrays mit mehr als drei Dimensionen sehr selten.

Wann nehme ich ein Array und wann etwas anderes?

Für die Speicherung von Daten gibt es neben Arrays auch andere Strukturen, zum Beispiel Listen (wie die ArrayList).

• Array: Die Kiste mit fester Größe

  • Die Größe eines Arrays (Anzahl der Fächer) wird bei der Erstellung festgelegt und kann nie wieder geändert werden.
  • Vorteil: Sehr schnell und speichereffizient, weil der Computer genau weiß, wie viel Platz er reservieren muss.
  • Ideal für: Daten, deren Größe sich nicht ändert. Beispiele: Ein Schachbrett (immer 8x8), die Monate im Jahr (immer 12), Pixel eines Bildes (feste Auflösung).

• Liste (z.B. ArrayList): Die dehnbare Einkaufstasche

  • Eine Liste ist dynamisch. Du kannst jederzeit Elemente hinzufügen oder entfernen, und die Liste passt ihre Größe automatisch an.
  • Vorteil: Extrem flexibel. Du musst die Größe nicht im Voraus kennen.
  • Ideal für: Daten, deren Anzahl unbekannt ist oder sich ständig ändert. Beispiele: Eine Einkaufsliste, eine Liste von angemeldeten Benutzern, die Chat-Nachrichten in einem Verlauf.

Faustregel für den Anfang:

• Weißt du genau, wie viele Elemente du speichern musst? Nimm ein Array.
• Ändert sich die Anzahl der Elemente ständig? Nimm eine Liste.

⏳ Lädt Dataview-Inhalt...

Zusammenfassung

Zusammenfassung:

Eindimensionale Arrays

Arrays ermöglichen die Speicherung mehrerer Werte gleichen Typs in einer strukturierten Form. Der Zugriff erfolgt über Indizes, beginnend bei 0.

• Eindimensionale Arrays sind linear aufgebaut und eignen sich für einfache Listen.
• Beispiel: Speicherung von Lottozahlen.
• Jeder Zugriff erfolgt über einen eindeutigen Index, z. B. array[0] für das erste Element.

Mehrdimensionale Arrays

Komplexere Datenstrukturen wie Tabellen oder Gitter können mit mehrdimensionalen Arrays abgebildet werden.

• Zweidimensionale Arrays werden als Tabelle mit Zeilen und Spalten dargestellt.
• Zugriff erfordert zwei Indizes: array[zeile][spalte].
• Typische Anwendungsfälle: Schachbrett, Sitzpläne, Excel-Tabellen.
• Initialisierung kann mit fester Größe oder direkt mit Werten erfolgen.
• Verarbeitung erfolgt über verschachtelte Schleifen.

Jagged Arrays

Jagged Arrays sind 2D-Arrays mit unterschiedlich langen Zeilen.

• Sie bieten mehr Flexibilität und sparen Speicher.
• Einsatz z. B. bei variabler Aufgabenanzahl pro Tag.

Dreidimensionale Arrays

3D-Arrays erweitern das Konzept auf eine weitere Ebene.

• Vorstellung: Stapel von Tabellen oder Würfel.
• Zugriff erfordert drei Indizes: Ebene, Zeile und Spalte.
• Typische Anwendungsfelder: Computergrafik, Bildverarbeitung, medizinische Bilddaten.

Arrays vs. Listen

Neben Arrays gibt es dynamische Listen wie die ArrayList.

• Arrays: feste Größe, effizient, für Daten mit konstanter Anzahl geeignet.
• Listen: dynamische Größe, flexibel, für Daten mit variabler Anzahl geeignet.

Faustregel:

• Feste, bekannte Datenmenge → Array.
• Variable, dynamische Datenmenge → Liste.

Ausblick

In der nächsten Lerneinheit lernst du die Datenstrukturen Heap und HashMap kennen. Du erfährst, wie ein Heap zur Priorisierung und effizienten Verwaltung von Elementen genutzt wird und wie eine HashMap durch Schlüssel-Wert-Zuordnungen den schnellen Zugriff auf Daten ermöglicht. Dabei wird deutlich, in welchen Situationen diese Strukturen besonders vorteilhaft sind und wie sie sich in ihrer Funktionsweise unterscheiden.

---