Im heutigen Teil dieser Tutorial-Reihe werden wir in Java Foreach Schleifen genauer unter die Lupe nehmen. Du wirst lernen, was eine Foreach Schleife ist und wie sie in der Praxis funktioniert.
Inhaltsverzeichnis
1. Eine Anmerkung vorab
Mit Sicherheit fragst du dich, warum ich jetzt schon wieder mit dem Thema Schleifen beginne. Schließlich haben wir uns bereits in den vorherigen Beiträgen ausgiebig damit beschäftigt.
Das liegt daran, dass die Foreach Schleife eine spezielle Art von Schleife ist, die ich dir erst erklären kann, wenn du bereits erste Datenstrukturen kennengelernt hast.
Da wir im letzten Beitrag auf das Array eingegangen sind, macht eine Einführung in die Foreach Schleife an dieser Stelle Sinn. Danach haken wir das ganze Schleifen-Thema dann aber auch ab, keine Sorge.
2. Was ist eine Foreach Schleife?
Bei einer Foreach Schleife handelt es sich um einen weiteren Schleifentypen, mit welchem man Datenstrukturen wie Arrays schrittweise durchlaufen kann. Die Java Foreach Schleife arbeitet dabei folgendermaßen:
Bei jedem Durchlauf speichert sie eine Kopie des aktuellen Wertes, je nach der Stelle, an der man sich im Array befindet, in einer Variable. Diese Variable können wir anschließend im Schleifenkörper verwenden.
Dabei ist ganz wichtig zu verstehen, dass man auf diese Variable nicht schreibend, sondern nur lesend zugreifen kann.
Eine Zuweisung vorzunehmen, wäre also beispielsweise nicht möglich, eine Ausgabe auf der Konsole hingegen schon. Wir können die Werte innerhalb des Arrays mit dieser Schleife dementsprechend nicht manipulieren.
Was ich damit genau meine, werde ich dir jetzt in der Praxis zeigen.
3. Die Java Foreach Schleife in der Praxis
Ich habe noch das Beispiel des vorherigen Beitrags geöffnet, in welchem wir uns mit dem Thema Arrays beschäftigt haben:
An dieser Stelle möchte ich dir eine weitere Variante zeigen, mit der du ein Array initialisieren kannst. In unserem vorherigen Beispiel haben wir ein Array mit drei Werten initialisiert.
Dafür haben wir nacheinander mit jeder Anweisung jeweils ein Element belegt. Wenn wir allerdings schon im Vorhinein wissen, in welcher Reihenfolge welches Element platziert werden soll, dann können wir das auch schneller umsetzen.
Hierfür kommentieren wir den bisherigen Code bis zur for Schleife aus:
Der kürzere Weg, ein Array zu initialisieren
Jetzt definieren wir das Array noch einmal neu und schreiben dafür folgendes:
System.out.println(names[1]);
*/
String[] names =
Bisher sieht die Zeile Code noch aus wie gewohnt. Aber anstatt nach dem =-Zeichen wieder „new String[3]“ zu schreiben, um vorerst ein leeres Objekt zu erzeugen, setzen wir geschweifte Klammern und ein Semikolon dahinter.
String[] names = {};
Zwischen die geschweiften Klammern können wir jetzt nacheinander unsere Werte schreiben. Als ersten Wert geben wir „Hendrik“ ein und danach folgen jeweils durch ein Komma voneinander getrennt noch „Paul“ und „Fabienne“:
String[] names = {"Hendrik", "Paul", "Fabienne"};
Wenn wir das Programm nochmal speichern und ausführen, erhalten wir durch die bereits existierende for Schleife wieder das gleiche Ergebnis:
Solltest du also schon genau wissen, welche Strings in welcher Reihenfolge im Array angeordnet werden müssen, kannst du diese direkt beim Initialisieren zwischen die geschweiften Klammern schreiben. Das impliziert nebenbei bemerkt auch automatisch, dass das Array eine Länge von drei Elementen hat.
Wir müssen die Größe demnach nirgendwo mehr angeben. Der Computer sieht nämlich, dass wir drei Strings übergeben und erkennt dadurch automatisch ein Array mit einer Länge von drei Elementen.
Die Wichtigkeit des length-Attributes
Das bedeutet im Umkehrschluss: Wenn wir names.length kurz löschen und durch die Zahl 4 ersetzen, überschreiten wir die Länge unseres Arrays. Beim Ausführen des Programms kommt uns auch schon eine Fehlermeldung entgegen:
Die Exception „ArrayIndexOutOfBoundsException“ weist uns direkt darauf hin, dass wir die Größe des Arrays überschritten haben.
Das habe ich dir bereits im letzten Beitrag gezeigt: Indem wir das length-Attribut verwenden, stellen wir sicher, dass wir die Länge nicht überschreiten und immer genau mit der maximalen Längenzahl arbeiten.
Beim erneuten Ausführen des Programms sehen wir wieder die richtigen Werte in der Konsole:
An dieser Stelle möchte ich auf die Foreach Schleife zu sprechen kommen, die ich vorhin bereits in der Theorie erklärt habe.
Die Foreach Schleife funktioniert sehr ähnlich wie die for Schleife.
Wir schreiben zunächst wieder das Schlüsselwort „for“. Der Inhalt, der anschließend in den runden Klammern folgt, sieht nun allerdings anders aus. Dazu schreiben wir erst mal folgendes:
for(int i = 0; 0 < names.length; i++) {
System.out.println(names[i]);
}
for(String name : names) {
System.out.println(name);
}
Führen wir das Programm nun so aus, erhalten wir die gleiche Ausgabe, die sich auch bei der oberen for Schleife ergibt:
Was ist hier nun anders?
4. So funktionieren in Java Foreach Schleifen
Nochmal kurz vorab: Man kann die Foreach Schleife nur verwenden, wenn man mit Datenstrukturen arbeitet. Also immer dann, wenn es sich um Verbindungen handelt, bei welchen mehrere Werte zusammengelegt sind.
In unserem Beispiel haben wir das Array „names“, in welchem sich mehrere Werte befinden. Demzufolge können wir dort die Foreach Schleife anwenden.
Wir schreiben in der Foreach Schleife zunächst den Typ, der in unserem Fall „String“ ist. Dann überlegen wir uns einen Bezeichner. Da sich in unserem Array Namen befinden, wählen wir hierfür „name“. Wir sagen mit der Foreach Schleife folgendes:
Durchlaufe das Array names und speichere bei jedem Durchlauf eine Kopie in der Variable name, die vom Typ String ist. Die Kopie muss vom Typ String sein, da alle Werte von names diesen Typ besitzen.
Um nochmal genauer darauf einzugehen:
Die Foreach Schleife durchläuft Schritt für Schritt das names-Array. Dabei arbeitet sie im ersten Durchlauf das erste Element ab, im zweiten Durchlauf das Zweite und nach diesem Schema geht es auch mit den nachfolgenden Elementen weiter.
Die Schleife soll dabei immer eine Kopie des Wertes an der aktuellen Stelle in die Variable name vom Typ String speichern.
Jetzt können wir im Codeblock auf die Variable, in die wir die Kopie speichern, zugreifen. In unserem Beispiel lassen wir einfach immer den Wert auf der Konsole ausgeben.
for(String name: names) {
System.out.println(name);
}
Das ist im Prinzip die gleiche Variante wie die for Schleife darüber, nur dass sich das Durchlaufen der Datenstrukturen mithilfe der Foreach Schleife intuitiver umsetzen lässt.
5. Darauf muss man bei der Java Foreach Schleife achten
Vorhin habe ich bereits in der Theorie erwähnt, dass bei dieser Schleife dennoch Vorsicht geboten ist. Wir speichern in der Variable name in jedem Durchlauf lediglich eine Kopie des Wertes im names-Array.
Da wir nur eine Kopie speichern, können wir den Wert in name nicht mehr ändern.
Die folgende Zeile Code im Schleifenblock wäre demnach nicht zulässig:
for(String name: names) {
name = "Test";
}
Wenn wir das Programm so ausführen, sehen wir, dass natürlich gar nichts passiert. Kopieren wir jetzt die obere for Schleife unter die Foreach Schleife und führen das Ganze aus, dann sehen wir nach wie vor „Hendrik“, „Paul“ und „Fabienne“ in der Konsole, obwohl wir in der Foreach Schleife jeden Wert auf „Test“ geändert haben.
String[] names = {"Hendrik", "Paul", "Fabienne"};
for(int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
for(String name: names) {
name = "Test";
}
for(int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
Das liegt daran, dass wir wirklich nur mit Kopien arbeiten. Die tatsächlichen Werte bleiben unangetastet und sind gesichert.
Wir benutzen die Foreach Schleife also nur, wenn wir lesend auf eine Datenstruktur zugreifen möchten.