Thema in Kurzform
Schleifen (engl. loops) ermöglichen es uns, bestimmte Anweisungen beliebig oft zu wiederholen, ohne dabei den entsprechenden Code jedes Mal neu schreiben zu müssen.
Es gibt mehrere verschiedene Schleifentypen, die je nach Einsatzweck sinnvoll gewählt werden können.
for-Schleife
Die for-Schleife ist der Klassiker unter den Schleifen. Eine for-Schleife besteht aus vier Teilen. Diese sind:
- Schleifenvariable Definition: Wir definieren die Schleifenvariable mit einem Startwert.
- Schleifenbedingung: Die Schleife wird solange wiederholt, wie die Prüfung eines booleschen Ausdrucks true ergibt. Sobald die Prüfung false ist, wird die Schleife beendet.
- Veränderung der Schleifenvariable: Nach jedem Schleifendurchlauf wird die Schleifenvariable verändert (zum Beispiel durch Hoch- oder Runterzählen um 1).
- Schleifenkörper: Beinhaltet die Anweisungen, die zu jedem Durchlauf der Schleife ausgeführt werden.
Diese vier Bausteine der for-Schleife sehen in der Java-Syntax konkret so aus:
Der Startwert der Schleifenvariablen i ist 0. Die Schleifenbedingung lautet i < 5, das heißt: Die Schleife wird solange wiederholt, wie i kleiner als 5 ist. i wird nach jedem Schleifendurchlauf um +1 erhöht.
Die Schleife in unserem Beispiel bewirkt, dass die Anweisung System.out.println(i); insgesamt fünfmal ausgeführt wird. ihat bei jedem Durchlauf einen anderen Wert. Das Ergebnis sieht auf der Konsole wie folgt aus:
0
1
2
3
4
In einem Aktivitätsdiagramm lässt sich die Logik dahinter so darstellen:
Dadurch, dass wir die gesamte Steuerung der Schleife in einer Zeile, dem Schleifenkopf, vornehmen können, ist die for-Schleife besonders übersichtlich. Sie eignet sich außerdem bestens, wenn wir wissen, wie oft ein Programmvorgang wiederholt werden soll.
Endlosschleife
Hüten Sie sich vor Schleifen, die Ihren Code ins Verderben führen, da sie niemals enden! Was glauben Sie, ist das Resultat des folgenden Codes:
for(int i = 0 ; i < 1; i--){
System.out.println("Ich bin ein Durchlauf");
}Richtig: Da die Bedingung i < 1 immer true ist und bleibt, wird die Schleife ewig laufen! Wir sitzen in einer Endlosschleife fest, aus der es kein Entrinnen gibt.
Passen sie also immer gut auf Ihre Schleifenvariable auf, damit die Schleifenbedingung irgendwann auch erfüllt werden kann.
while-Schleife
Die while-Schleife eignet sich gut, wenn wir zu Beginn noch nicht wissen, wieviele Schleifendurchläufe benötigt werden. Um eine while-Schleife zu starten, benutzen wir das Schlüsselwort while und schreiben direkt dahinter die Schleifenbedingung in runden Klammern. Es folgt der Schleifenkörper mit den auszuführenden Anweisungen. Hier ein praktisches Beispiel:
int number = 0;
while(number != 6){
number = (int) ((Math.random() * 6)+1);
System.out.print(number + " ");
}Am Beispiel wird die Schleife solange wiederholt, wie die Variable number nicht den Wert 6 hat. Am Ende jeder Anweisung wird der Wert von number mit Hilfe einer Zufallszahl zwischen 1 und 6 neu ermittelt. Die Schleife wird somit irgendwann enden - wir wissen aber nicht genau wann. Ein mögliches Ergebnis ist folgender Konsolenprint:
3 4 3 3 6
Der wesentliche Unterschied zur for-Schleife ist, dass bei der while-Schleife nur die Schleifenbedingung im Schleifenkopf (in den runden Klammern) steht. Die Schleifenvariable dagegen wird außerhalb der Schleifenkonstruktion definiert und die Schleifensteuerung erfolgt im Schleifenkörper.
do-while-Schleife
Die do-while-Schleife ist der while-Schleife recht ähnlich. Der Unterschied ist aber, dass die Prüfung zur Wiederholung erst am Ende, nach einem Schleifendurchlauf erfolgt. Das hat zur Konsequenz, dass die Schleife in jedem Fall mindestens einmal durchlaufen wird:
Im Gegensatz zu anderen Schleifentypen gibt es bei der do-while-Schleife also auf jeden Fall eine Code-Runde gratis.
Unser Zufallszahlen-Beispiel von oben sieht in einer do-while-Schleife dann so aus:
int number = 6;
do{
number = (int) ((Math.random() * 6)+1);
System.out.print(number + " ");
}
while(number != 6);Syntaktisch hat sich einiges getan: Der auszuführende Code-Block wird nun vom Schlüsselwort do eröffnet, während am Ende while mit der Prüfung zur Wiederholung in runden Klammern steht.
Es spielt nun keine Rolle, ob die Schleifenbedingung zu Beginn erfüllt ist oder nicht, wenn es darum geht, dass der Code-Block mindestens einmal ausgeführt werden soll. Genau das ist in unserem Beispiel auch der Fall: Denn obwohl die Schleifenbedingung nicht erfüllt ist (number = 6), wird die Schleife trotzdem ausgeführt. Mit einer for- oder while-Schleife hätten wir keinen einzigen Schleifendurchlauf bekommen, da dort die Prüfung vor dem ersten Schleifendurchlauf steht.
foreach-Schleife
Die foreach-Schleife wurde speziell dafür erfunden, die einzelnen Elemente einer Sammlung (z.B. eines Arrays) zu durchlaufen. Für jedes dieser Elemente wird die immer gleiche Anweisungen ausgeführt, wie sie im Schleifenkörper beschrieben ist.
Die allgemeine Syntax sieht wie folgt aus:
Nach dem Schlüsselwort for schreiben wir in die runden Klammern nacheinander den Datentyp der Arrays-Elemente. Anschließend folgt die Benennung der Schleifenvariablen (hier: sV) und nach dem Doppelpunkt der Name des Arrays. Die geschweiften Klammern { } umschließen den Schleifenkörper mit den Schleifenanweisungen.
Es gibt soviele Schleifendurchläufe wie es Elemente im Array gibt und bei jedem Durchlauf wird die Schleifenvariable sV mit dem Wert desjenigen Array-Elements belegt, das gerade an der Reihe ist. Beim ersten Durchlauf wird der Wert des ersten Array-Elements in die Schleifenvariable sV kopiert. Beim zweiten Durchlauf wird der Wert des zweiten Array-Elements in sVkopiert und so weiter. Auf diese Weise können wir auf allen Elementen eines Arrays dieselbe Anweisung durchführen.
Hier ein konkretes Beispiel:
String[] familien = {"Lannister", "Stark", "Targaryen", "Bolton", "Tyrell"};
for(String sV : familien){
System.out.println(sV);
}Nachdem wir zunächst ein Array aus Strings mit dem Namen familien und fünf Elementen definiert haben, lassen wir es in einer foreach-Schleife durchlaufen. Bei jedem der fünf Schleifendurchläufe wird jeweils das nächste Array-Elemente nacheinander in die Schleifenvariable kopiert und entsprechend auf der Konsole geprinted.
Verschachtelte Schleifen
Wenn im Schleifenkörper eine (oder mehrere) andere Schleifen stehen, sprechen wir von ineinander verschachtelten Schleifen. Theoretisch können wir beliebig oft verschachteln. Der Einfachheit halber beschränken wir uns hier aber auf eine einfache Verschachtelung mit zwei Schleifen. Bei einer einfachen Verschachtelung haben wir immer eine äußere und eine innereSchleife. Hier ein Beispiel, wie Sie es oft finden:
for(int i = 1; i<4; i++){ // äußere Schleife
for(int y = 1; y<4; y++){ // innere Schleife
System.out.println(i + " " + y);
}
}Was läuft hier ab?
Der Code läuft in den ersten Durchlauf der äußeren Schleife, wo die innere Schleife komplett durchlaufen wird. Danach geht es in den zweiten Durchlauf der äußeren Schleife, worin wieder die innere Schleife von Neuem durchlaufen wird. Dieses Spiel geht solange weiter, bis die äußere Schleife beendet wird. Innerhalb der inneren Schleife wird mit System.out.println der aktuelle Wert der beiden Schleifenvariablen i und y auf der Konsole geprinted:
1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3
Zur besseren Veranschaulichung sind die einzelnen Schritte in der folgenden Tabelle gelistet:
| äußere Schleife | innere Schleife | Variable i | Variable y |
|---|---|---|---|
| Erster Durchgang | erster Durchgang | 1 | 1 |
| zweiter Durchgang | 1 | 2 | |
| dritter Durchgang | 1 | 3 | |
| Zweiter Durchgang | erster Durchgang | 2 | 1 |
| zweiter Durchgang | 2 | 2 | |
| dritter Durchgang | 2 | 3 | |
| Dritter Durchgang | erster Durchgang | 3 | 1 |
| zweiter Durchgang | 3 | 2 | |
| dritter Durchgang | 3 | 3 |
Verschachtelte Schleifen bei mehrdimensionalen Arrays
Der volle Nutzen von verschachtelten Schleifen zeigt sich in der Arbeit mit mehrdimensionalen Arrays. Sehen wir uns ein kleines 2D-Array an:
char[][] letters = {{'a', 'A'}, {'b', 'B'}, {'c', 'C'}};Das zweidimensionale Beispiel-Array hat insgesamt drei weitere Arrays als Elemente, wovon jedes wiederum zwei char-Elemente hält. Um alle char-Elemente (insgesamt 6) zu fassen, schreiben wir die Schleifenkonstruktion wie folgt:
// Array definieren....
for(int i = 0; i < letters.length; i++){
for(int y = 0; y < letters[i].length; y++){
System.out.print(letters[i][y] + " ");
}
System.out.println("");
}Die äußere Schleife wird so oft wiederholt, wie das Array auf der ersten Ebene Elemente hat (letters.length), also dreimal. Die innere Schleife kümmert sich dann nacheinander um die char-Elemente des aktuellen char-Arrays, das an der Reihe ist, und wird entsprechend seiner Länge wiederholt (letters[i].length). Der Output auf der Java-Konsole ist dann erwartungsgemäß:
a A
b B
c C
continue und break
Die beiden Anweisungen continue und break können innerhalb von Schleifen eingesetzt werden, um einen Schleifendurchlauf bzw. die gesamte Schleife vorzeitig zu beenden.
continue
Der Einsatz von continue innerhalb einer Schleife sorgt für den Abbruch des aktuellen Schleifendurchlaufs:
for(int i = 0 ; i < 5; i++){
if(i == 3){
continue;
}
System.out.print(i + " ");
}Ausgabe:
0 1 2 4
Es fehlt die 3! Der Grund: Wenn die Schleifenvariable i den Wert 3 annimmt, wird die Anweisung continue ausgeführt, womit der aktuelle Schleifendurchlauf sofort beendet wird und der nächste startet. Deshalb kommt es beim Durchlauf mit i == 3nicht zum System.out.print.
break
Im Gegensatz zu continue beendet break erbarmungslos sofort die ganze Schleife. Ersetzen wir in unserem Schleifenbeispiel einmal continue mit break und sehen, was passiert:
for(int i = 0 ; i < 5; i++){
if(i == 3){
break;
}
System.out.print(i + " ");
}Da die Schleife mitten im vierten Durchlaufen (i == 3) beendet wird, sieht das Ergebnis auf der Java-Konsole so aus:
0 1 2
