In diesem Blogartikel wird sich alles um mehrdimensionale Arrays drehen. Dabei wirst du lernen, was ein mehrdimensionales Array überhaupt ist, wie es sich von normalen Arrays unterscheidet und wie du es selbst in der Praxis programmieren kannst.
Sie sehen gerade einen Platzhalterinhalt von Youtube. Um auf den eigentlichen Inhalt zuzugreifen, klicken Sie auf die Schaltfläche unten. Bitte beachten Sie, dass dabei Daten an Drittanbieter weitergegeben werden.
Mehr InformationenInhaltsverzeichnis
1. Was ist ein mehrdimensionales Array?
Genau wie bei gewöhnlichen Arrays handelt es sich bei einem mehrdimensionalen Array um eine Datenstruktur, also eine Datensammlung. Das Prinzip von mehrdimensionalen Arrays gleicht auch dem der normalen Arrays, welche man nebenbei bemerkt auch als eindimensionale Arrays bezeichnet.
Wie unterscheiden sich mehrdimensionale Arrays von gewöhnlichen Arrays?
Der Unterschied besteht darin, dass man bei mehrdimensionalen Arrays mehrere Dimensionen verwenden kann. Sehen wir uns das Ganze nun mal anhand einer kleinen Skizze an.
Auf der Abbildung erkennen wir ein gewöhnliches Array, das man sich wie eine Liste mit einer gewissen Reihenfolge vorstellen kann. Die 0 zwischen den Klammern soll das Feld repräsentieren, auf welchem ein Wert gespeichert ist. Man kann diesen Wert, welcher gleichzeitig das erste Element des Arrays darstellt, über den Index 0 ansprechen.
Dann folgt Index 1, womit wir das zweite Element des Arrays ansprechen können. Mit Index 2 sprechen wir das dritte Element an und so geht es immer weiter.
Bei mehrdimensionalen Arrays verhält es sich genauso, mit dem Unterschied, dass es bei diesen mehr Dimensionen gibt. Auf der folgenden Skizze eines zweidimensionalen Arrays können wir uns das Ganze mal veranschaulichen.
Beispiel eines zweidimensionalen Arrays
Wie wir sehen, haben wir dort keine Reihe mehr, wie es bei den eindimensionalen Arrays der Fall war, sondern eine Tabelle. Folglich gibt es jetzt auch zwei Indizes, um ein Element sicher identifizieren zu können.
Oben links in der Ecke sehen wir in Klammern 0|0, wobei die orange Null den Index symbolisiert, welcher uns zeigt, in welcher Zeile der Tabelle wir uns befinden. Auch hier fangen wir wieder bei 0 an zu zählen.
Damit hat die erste Zeile den Index 0. Die weiße Null daneben, gibt an, in welcher Spalte der Tabelle wir uns befinden. Auch hier beginnen wir bei null zu zählen und sind damit aktuell in der ersten Spalte.
Ein Feld daneben (0 | 1) befinden wir uns noch immer in der ersten Zeile, weshalb dort auch wieder der Index 0 steht. Die zweite Zahl ist nun die Eins, da wir in der zweiten Spalte sind.
Dieses Schema zieht sich die gesamte Tabelle hindurch. Wenn wir beispielsweise das Element ansprechen möchten, das sich in der dritten Zeile und dritten Spalte befindet, müssen wir in der Tabelle Ausschau nach dem orangen Index 2 halten. Schließlich gibt dieser an, dass wir uns in der dritten Zeile befinden.
Um noch in die dritte Spalte zu gelangen, suchen wir rechts beim Spaltenindex ebenfalls nach der Zahl 2. Diese befindet sich unten in der Mitte, wodurch wir das Element auch schon gefunden haben:
Arrays mit mehr als zwei Dimensionen
Mit mehreren Dimensionen verhält es sich im Grunde genauso. Bei drei Dimensionen haben wir beispielsweise nicht mehr die Form einer Tabelle, sondern die eines dreidimensionalen Würfels.
Auch vier- oder fünfdimensionale Arrays sind im Programm umsetzbar. Da besteht dann allerdings das Problem, dass wir Menschen uns das nicht mehr vorstellen können. In der Regel kommen wir aber ohnehin höchstens mit zweidimensionalen Arrays in Berührung.
Solltest du sehr naturwissenschaftliche Programme schreiben, kann es sein, dass du mehr als eine oder zwei Dimensionen benötigst. Das bildet aber wie gesagt eher die Ausnahme.
Aus diesem Grund werden wir uns jetzt im Praxisteil dieses Beitrags auf ein zweidimensionales Array beschränken. Analog dazu lassen sich dann auch Arrays mit mehr als zwei Dimensionen programmieren.
2. Mehrdimensionale Arrays in der Praxis
Jetzt sehen wir uns das ganze Thema mal in der Praxis anhand einer Tabelle an. Wir möchten ein zweidimensionales Array programmieren und darin logisch zueinander gehörende Vor- und Nachnamen speichern.
Unsere Tabelle wird beispielhaft fünf Zeilen und zwei Spalten haben. Die erste Spalte ist dabei immer für den Vornamen und die zweite Spalte für den Nachnamen einer Person gedacht.
Dass wir hierfür den Datentyp String benötigen, dürfte an diesem Punkt klar sein. Schließlich möchten wir Namen speichern.
Bei den eindimensionalen Arrays war es bisher so, dass wir ein eckiges Klammerpaar hinter den Datentyp beim Erstellen eines Arrays setzen mussten.
Wenn wir mit zweidimensionalen Arrays arbeiten, benötigen wir zwei eckige Klammerpaare, da wir noch einen zusätzlichen Index verwenden. Anschließend folgt wie gewohnt der Bezeichner des Arrays. Wir wählen dafür beispielhaft „firstAndLastName“ und setzen die Zeile folgendermaßen fort:
String [][] firstAndLastName = new String[5][2]
Da auch mehrdimensionale Arrays eine feste Größe besitzen, habe ich diese ebenfalls direkt festgelegt.
Wie bereits anfangs erwähnt, möchten wir fünf Zeilen und zwei Spalten. Eine der Spalten soll für den Vornamen und eine für den Nachnamen genutzt werden. Der erste Index und damit die erste eckige Klammer steht immer für die Zeilen und die zweite eckige Klammer steht für die Spalten.
Dem zweidimensionalen Array Werte zuweisen
Jetzt können wir in der ersten Zeile schon mal den ersten Namen speichern. Das funktioniert wie bei den eindimensionalen Arrays. Dazu schreiben wir erst den Namen des Arrays und anschließend die beiden eckigen Klammern, die für die Zeile und die Spalte stehen. Um das Element zuweisen zu können, das sich in der ersten Zeile und in der ersten Spalte befinden soll, verwenden wir jeweils die Zahl 0. Wir weisen hier beispielhaft den Namen „Franz“ zu:
String [][] firstAndLastName = new String[5][2];
firstAndLastName[0][0] = "Franz";
Danach kopieren wir diese Zeile Code und fügen sie darunter nochmal ein. Nun möchten wir die zweite Spalte der ersten Zeile noch ansprechen. Wir fügen also beim Spaltenindex eine 1 ein und speichern den Nachnamen „Bauer“ darin.
firstAndLastName[0][0] = "Franz";
firstAndLastName[0][1] = "Bauer";
Diesen Vorgang wiederholen wir auch noch bei zwei weiteren Zeilen. Wenn wir diese kopieren und unter dem bisherigen Code einfügen, müssen wir lediglich noch den Zeilenindex ändern. Da wir uns in der zweiten Zeile befinden, tragen wir jeweils den Index 1 ein. Anschließend weisen wir noch den Namen „Felix Huber“ zu:
firstAndLastName[1][0] = "Felix";
firstAndLastName[1][1] = "Huber";
Für die dritte Zeile benötigen wir Index 2 und darin speichern wir „Fritz Meier“:
firstAndLastName[2][0] = "Fritz";
firstAndLastName[2][1] = "Meier";
3. Wie gibt man mehrdimensionale Arrays auf der Konsole aus?
An dieser Stelle möchten wir uns das Ganze natürlich noch auf der Konsole ausgeben lassen, damit wir sehen, ob es funktioniert hat. Hierfür setzen wir for-Schleifen ein, damit wir uns das Array in einem Zug ausgeben lassen können.
Wir erstellen dafür zunächst eine äußere For-Schleife. Mit einem Kommentar im Code können wir diesen Schritt dokumentieren:
firstAndLastName[2][1] = "Meier";
//Äußere For-Schleife: Zeilenindex => i
Diese Schleife bezieht sich immer auf den Zeilenindex, der „i“ sein soll. Zusätzlich soll es noch eine innere For-Schleife geben, die sich auf den Spaltenindex bezieht. Wir nennen diesen beispielhaft „j“.
//Äußere For-Schleife: Zeilenindex => i
//Innere For-Schleife: Spaltenindex => j
In der Praxis setzen wir das Ganze jetzt folgendermaßen um:
//Innere For-Schleife: Spaltenindex => j
for(int i = 0; i < firstAndLastName.length; i++) {
}
Danach folgt die zweite For-Schleife:
for(int i = 0; i < firstAndLastName.length; i++) {
for(int j = 0; j < firstAndLastName[i].length; j++) {
}
}
Jetzt, wo wir Zeilen- und Spaltenindex haben, können wir uns das Ganze ausgeben lassen. Dafür schreiben wir in die println-Methode den Namen des Arrays und zwei eckige Klammerpaare, in die wir den Zeilenindex i und den Spaltenindex j setzen. Mit diesen Indizes können wir das Array durchlaufen und ausgeben lassen:
for(int i = 0; i < firstAndLastName.length; i++) {
for(int j = 0; j < firstAndLastName[i].length; j++) {
System.out.println(firstAndLastName[i][j]);
}
}
4. Erläuterung des Codes
Um die Grenzen des Arrays nicht zu überschreiten, verwenden wir in den For-Schleifen wieder das length-Attribut.
Bei den eindimensionalen Arrays haben wir den Array-Namen angegeben, einen Punkt gesetzt und anschließend „length“ ergänzt. Damit konnten wir die maximale Länge des Arrays automatisch ermitteln lassen.
Bei den mehrdimensionalen Arrays gibt es zum einen die Index-Reihe für die Zeilen und zum anderen die Index-Reihe für die Spalten.
Um uns die maximale Spaltenanzahl ausgeben zu lassen, schreiben wir den Namen des Arrays, nämlich „firstAndLastName“ und anschließend in einem eckigen Klammerpaar eine Integerzahl, die die Zeile angibt, in der wir uns aktuell befinden. Anschließend lassen wir noch mit .length die maximale Anzahl der Spalten ermitteln, die sich in dieser Zeile befindet.
Da wir mit i über die Zeilen laufen, schreiben wir bei der inneren for-Schleife in das eckige Klammerpaar hinter dem Array-Namen „i“. Damit du das Ganze besser verstehen kannst, führen wir das Programm direkt einmal aus.
In der Ausgabe steht Folgendes:
Wir sehen nun die Werte, die wir in die ersten Zeilen und Spalten gespeichert haben und darüber hinaus viermal „null“. Letzteres wird ausgegeben, weil es noch zwei weitere Zeilen mit jeweils zwei Spalten gibt, in die wir keine Werte geschrieben haben.
5. Die Ausgabe des Arrays übersichtlicher gestalten
Da die Ausgabe noch ziemlich unübersichtlich dargestellt wird und nicht die Form des Arrays im vorherigen Bild zeigt, passen wir den Code noch etwas an. Wir legen also fest, dass kein Zeilenumbruch stattfinden soll, wenn wir die unterschiedlichen Elemente der verschiedenen Spalten ausgeben lassen. Damit am Ende nicht alles zusammenklebt, fügen wir noch eine Leerzeile hinten an.
for(int i = 0; i < firstAndLastName.length; i++) {
for(int j = 0; j < firstAndLastName[i].length; j++) {
System.out.print(firstAndLastName[i][j] + " ");
}
}
Nach jeder Zeile, die vollständig ausgegeben wurde, soll dann ein Zeilenumbruch gesetzt werden:
for(int i = 0; i < firstAndLastName.length; i++) {
for(int j = 0; j < firstAndLastName[i].length; j++) {
System.out.print(firstAndLastName[i][j] + " ");
}
System.out.println();
}
Wenn wir das Programm erneut ausführen, sehen wir die Struktur des zweidimensionalen Arrays perfekt. Dieses hat insgesamt fünf Zeilen und zwei Spalten, wie wir auf der Konsole erkennen können:
Wie bereits am Anfang erwähnt, wirst du in den meisten Fällen höchstens mit zweidimensionalen Arrays in Berührung kommen. In diesem Fall kannst du sie mithilfe der For-Schleife auf der Konsole ausgeben lassen, indem du die Konstruktion der for-Schleifen beachtest.
Bei der äußeren For-Schleife gibst du den Namen des Arrays sowie das length-Attribut an und bei der inneren For-Schleife ergänzt du nach dem Array-Namen ein eckiges Klammerpaar. Darin spezifizierst du die Zeile, von welcher du die Spaltenanzahl ausgeben lassen möchtest.
Die Arbeit mit mehrdimensionalen Arrays unterscheidet sich von der Arbeit mit gewöhnlichen Arrays also insofern, als man ein weiteres eckiges Klammerpaar ergänzen muss.
Wenn du ein dreidimensionales Array erstellen möchtest, setzt du anstatt zwei eckigen Klammerpaaren, einfach drei.
So verhält es sich analog zu allen Dimensionen. Dir sind also keine Grenzen gesetzt und du musst lediglich darauf achten, dass du genügend Speicher hast und vor allem, dass du etwas Sinnvolles damit umsetzen kannst.