Möchtest du bestimmte Programmabschnitte in Java wiederholt ausführen lassen? Dann sind Schleifen das perfekte Werkzeug für dich.
In Java stehen Entwicklern drei verschiedene Arten von Schleifen zur Verfügung. Um die passende Schleifenart für deinen Anwendungsfall auszuwählen, ist es wichtig, die Besonderheiten der Schleifen zu kennen und zu verstehen.
In diesem Beitrag behandeln wir die drei Java-Schleifenarten. Wir beginnen mit der abweisenden while-Schleife, gefolgt von der nichtabweisenden do-while-Schleife und der for-Schleife, die sich besonders gut als Zählerschleife eignet.
Die while-Schleife in Java
Die while-Schleife überprüft zuerst den Testausdruck. Nur wenn das Ergebnis true ist, wird die Schleifenanweisung ausgeführt. Es handelt sich also um eine abweisende Schleifenart.
Die Schleifenanweisung kann auch ein Block mit mehreren Anweisungen sein, der in geschweifte Klammern eingeschlossen werden muss.
Ist das Ergebnis des Testausdrucks false, wird die Schleifenanweisung übersprungen. Der Rückgabewert des Testausdrucks muss immer vom boolean-Datentyp sein.
Nachdem die while-Schleife einmal durchlaufen wurde, wird erneut der Testausdruck geprüft. Die Schleife wird so lange durchlaufen, bis der Testausdruck false wird und die Schleifenanweisung nicht mehr ausgeführt wird.
while (Testausdruck)
Schleifenanweisung;
while (Testausdruck) {
Schleifenanweisung1;
Schleifenanweisung2;
}Die do-while-Schleife in Java
Die do-while-Schleife führt die Schleifenanweisung immer mindestens einmal aus und ist daher eine nichtabweisende Schleifenart.
Nachdem die Schleifenanweisung zum ersten Mal ausgeführt wurde, wird der Testausdruck überprüft. Ist das Ergebnis true, wird die Schleifenanweisung erneut ausgeführt. Ist das Ergebnis false, wird die do-while-Schleife beendet.
Der Rückgabewert des Testausdrucks muss, wie bei der while-Schleife, vom boolean-Datentyp sein.
do
Schleifenanweisung;
while (Testausdruck);
do {
Schleifenanweisung1;
Schleifenanweisung2;
} while (Testausdruck)Die for-Schleife in Java
Die for-Schleife wird in Java oft als Zählerschleife verwendet. Sie zählt einen Zähler hoch und wiederholt bestimmte Anweisungen entsprechend oft.
Der Schleifenkopf der for-Schleife besteht aus drei Ausdrücken, von denen keiner zwingend erforderlich ist:
- Initialisierungsausdruck: Führt eine Initialisierung vor dem Start der Schleife durch.
- Testausdruck: Wird zu Beginn der Schleife überprüft und entscheidet, ob die Schleife betreten wird.
- Updateausdruck: Führt Veränderungen nach jedem Schleifendurchlauf aus, z.B. die Erhöhung des Schleifenzählers.
Es können mehrere Einzelausdrücke in den Initialisierungs- und Updateausdruck angegeben werden, die durch ein Komma getrennt werden.
Ist kein Initialisierungsausdruck angegeben, wird keine Initialisierung vor dem Start der for-Schleife durchgeführt.
Das Gleiche gilt für den Updateausdruck. Oft wird der Initialisierungsausdruck genutzt, um Zählervariablen zu deklarieren, die nur innerhalb des Schleifenblocks sichtbar sind.
Ist kein Testausdruck angegeben, setzt der Java-Compiler automatisch true an diese Stelle, was zu einer Endlosschleife führt.
for (Initialisierung; Test; Update)
Schleifenanweisung;
for (Initialisierung; Test; Update) {
Schleifenanweisung1;
Schleifenanweisung2;
}Quellcode-Beispiele für die drei Schleifenarten in Java
Hier sind Beispiele für die drei Schleifenarten in Java:
/* Beispielanwendung Schleifen in Java. */
public class Schleifen {
public static void main(String[] args) {
int a = 1, b = 1;
System.out.println();
while (a < 10) {
System.out.println("Schleifendurchlauf " + a);
if (a == 9)
System.out.println();
a++;
}
do {
System.out.println("Schleifendurchlauf " + b);
if (b == 9)
System.out.println();
b++;
} while (b < 10);
for (int c = 1, d = 19, jahr = 2013; c < d; c++, d--) {
System.out.print("Schleifendurchlauf " + c + " im Jahr " + jahr + ".");
System.out.println(" c = " + c + ", d = " + d);
}
}
}In diesem Beispiel werden die drei Schleifenarten in der folgenden Reihenfolge verwendet:
- while-Schleife (Zeile 11 bis 16)
- do-while-Schleife (Zeile 19 bis 25)
- for-Schleife (Zeile 28 bis 32)
Der Quellcode ist größtenteils selbsterklärend. Eine erwähnenswerte Besonderheit ist der Schleifenkopf der for-Schleife in Zeile 28. Hier werden drei Variablen deklariert und initialisiert: int c = 1, d = 2, jahr = 2013. Zwei dieser Variablen werden im Updateausdruck inkrementiert bzw. dekrementiert: c++, d–.
Verändern der Auswertungsreihenfolge von Schleifen in Java mit der continue- und break-Anweisung
Mit den Schlüsselwörtern continue und break kann die Auswertungsreihenfolge von Schleifen in Java verändert werden.
Die continue-Anweisung wird verwendet, um den aktuellen Schleifendurchlauf zu beenden und mit der nächsten Iteration der Schleife fortzufahren. Das Programm springt zum Ende der Schleife und beginnt dann die Schleife von vorne.
Die break-Anweisung wird verwendet, um eine Schleife vorzeitig zu beenden. Das Programm springt aus der Schleife und setzt die Ausführung mit der ersten Anweisung nach der Schleife fort.
Hinweis: Wenn Schleifen ineinander verschachtelt sind, wirkt die continue- oder break-Anweisung immer auf die Schleife, in der sie steht. Um äußere Schleifen zu verlassen, muss die entsprechende Schleife mit einem Label versehen werden.
Beispiele für die continue- und break-Anweisung in Java
Hier sind Beispiele für die Verwendung der continue- und break-Anweisung:
/* Beispielanwendung Auswertungsreihenfolge von Schleifen verändern. */
public class SchleifenAnweisungen1 {
public static void main(String[] args) {
int a = 1, b = 1, c = 1;
System.out.println();
while (a <= 5) {
System.out.println("Schleifendurchlauf " + a);
a++;
}
System.out.println();
while (b <= 5) {
if (b == 3) {
System.out.println("Continue-Anweisung wird ausgeführt. b = " + b);
b++;
continue;
}
System.out.println("Schleifendurchlauf " + b);
b++;
}
System.out.println();
while (c <= 5) {
if (c == 3) {
System.out.println("Break-Anweisung wird ausgeführt. c = " + c);
break;
}
System.out.println("Schleifendurchlauf " + c);
c++;
}
}
}In diesem Beispiel werden die continue- und break-Anweisung verwendet.
Im oberen Teil des Codes (Zeile 11 bis 16) wird eine normale while-Schleife verwendet, die in jedem Durchlauf eine Zeichenkette mit dem aktuellen Schleifendurchlauf ausgibt.
Im mittleren Teil des Codes (Zeile 20 bis 33) wird dieselbe while-Schleife verwendet, jedoch wird im dritten Schleifendurchlauf die continue-Anweisung ausgeführt. Dadurch springt das Programm sofort zum Ende des Schleifenkörpers in Zeile 33 und startet die Schleife erneut.
Im unteren Teil des Codes (Zeile 37 bis 49) wird anstelle der continue-Anweisung die break-Anweisung verwendet. Dadurch wird beim Erreichen der break-Anweisung (im dritten Durchlauf) die Schleife sofort beendet und verlassen.
In der Abbildung unten ist die Ausgabe des Programms in der Kommandozeile dargestellt.
Beispiele für die break-Anweisung in verschachtelten Schleifen in Java
Hier sind Beispiele für die Verwendung der break-Anweisung in verschachtelten Schleifen:
/* Beispielanwendung Auswertungsreihenfolge von Schleifen verändern. */
public class SchleifenAnweisungen2 {
public static void main(String[] args) {
int c = 1, d = 1;
System.out.println();
while (c < 5) {
System.out.println("- Aussere Schleife. c = " + c);
while (d < 5) {
System.out.println("- Innere Schleife. d = " + d);
d++;
}
c++;
d = 1;
}
System.out.println();
c = 1;
d = 1;
while (c < 5) {
System.out.println("- Aussere Schleife. c = " + c);
while (d < 5) {
if (d == 3) {
System.out.println("- Innere Schleife. Break-Anweisung.");
break;
}
System.out.println("- Innere Schleife. d = " + d);
d++;
}
c++;
d = 1;
}
System.out.println();
c = 1;
d = 1;
while (c < 5) {
if (c == 3) {
System.out.println("- Aussere Schleife. Break-Anweisung.");
break;
}
System.out.println("- Aussere Schleife. c = " + c);
while (d < 5) {
System.out.println("- Innere Schleife. d = " + d);
d++;
}
c++;
d = 1;
}
}
}In diesem Beispiel wird die break-Anweisung in verschachtelten Schleifen verwendet.
Im oberen Teil des Codes (Zeile 12 bis 24) sind zwei normale while-Schleifen ineinander verschachtelt, die in jedem Durchlauf eine Zeichenkette mit dem aktuellen Schleifendurchlauf ausgeben.
Im mittleren Teil des Codes (Zeile 28 bis 46) sind dieselben while-Schleifen angegeben, jedoch wird in der inneren Schleife im dritten Schleifendurchlauf die break-Anweisung ausgeführt. Dadurch springt das Programm sofort zum Ende des inneren Schleifenkörpers in Zeile 44 und beide Schleifen werden verlassen.
Im unteren Teil des Codes (Zeile 50 bis 68) wird die break-Anweisung in der äußeren Schleife ausgeführt. Dadurch wird beim Erreichen der break-Anweisung (im dritten Durchlauf) die äußere Schleife sofort beendet und verlassen. Die innere Schleife wird nicht erneut ausgeführt.
In der Abbildung unten ist die Ausgabe des Programms in der Kommandozeile dargestellt.
Beispiele für die continue-Anweisung in verschachtelten Schleifen in Java
Hier sind Beispiele für die Verwendung der continue-Anweisung in verschachtelten Schleifen:
/* Beispielanwendung Auswertungsreihenfolge von Schleifen verändern. */
public class SchleifenAnweisungen3 {
public static void main(String[] args) {
int c = 1, d = 1;
System.out.println();
while (c < 5) {
System.out.println("- Aussere Schleife. c = " + c);
while (d < 5) {
System.out.println("- Innere Schleife. d = " + d);
d++;
}
c++;
d = 1;
}
System.out.println();
c = 1;
d = 1;
while (c < 5) {
System.out.println("- Aussere Schleife. c = " + c);
while (d < 5) {
if (d == 3) {
d++;
System.out.println("- Innere Schleife. Continue-Anweisung.");
continue;
}
System.out.println("- Innere Schleife. d = " + d);
d++;
}
c++;
d = 1;
}
System.out.println();
c = 1;
d = 1;
while (c < 5) {
if (c == 3) {
c++;
System.out.println("- Aussere Schleife. Continue-Anweisung.");
continue;
}
System.out.println("- Aussere Schleife. c = " + c);
while (d < 5) {
System.out.println("- Innere Schleife. d = " + d);
d++;
}
c++;
d = 1;
}
}
}In diesem Beispiel wird die continue-Anweisung in verschachtelten Schleifen verwendet.
Im oberen Teil des Codes (Zeile 12 bis 24) sind zwei normale while-Schleifen ineinander verschachtelt, die in jedem Durchlauf eine Zeichenkette mit dem aktuellen Schleifendurchlauf ausgeben.
Im mittleren Teil des Codes (Zeile 29 bis 49) sind dieselben while-Schleifen angegeben, jedoch wird in der inneren Schleife im dritten Schleifendurchlauf die continue-Anweisung mit dem Label labelContinueSchleife ausgeführt.
Dadurch springt das Programm sofort zum Ende des äußeren Schleifenkörpers, da die äußere Schleife das Label labelContinueSchleife trägt, und startet die äußere Schleife erneut.
Im unteren Teil des Codes (Zeile 54 bis 73) wird die continue-Anweisung in der äußeren Schleife ausgeführt. Dadurch wird beim Erreichen der continue-Anweisung (im dritten Durchlauf) zum Ende der äußeren Schleife gesprungen und diese erneut ausgeführt.
In der Abbildung unten ist die Ausgabe des Programms in der Kommandozeile dargestellt.
Schleifen mit Label – Gelabelte break- und continue-Anweisungen in Java
Möchtest du aus mehrfach geschachtelten Schleifen springen, müssen gelabelte Sprunganweisungen verwendet werden. Damit kannst du mehrfach geschachtelte Schleifen mit einer gelabelten break-Anweisung vorzeitig beenden, unabhängig von ihrer Position.
Verwendest du eine mit einem Label versehene break- oder continue-Anweisung, muss das verwendete Label den Block umschließen, in dem sich die gelabelte Anweisung befindet.
/* Beispielanwendung Auswertungsreihenfolge von Schleifen verändern mit Labeln. */
public class SchleifenAnweisungen4 {
public static void main(String[] args) {
int c = 1, d = 1;
System.out.println();
while (c < 5) {
System.out.println("- Aussere Schleife. c = " + c);
while (d < 5) {
System.out.println("- Innere Schleife. d = " + d);
d++;
}
c++;
d = 1;
}
System.out.println();
c = 1;
d = 1;
labelContinueSchleife: while (c < 5) {
System.out.println("- Aussere Schleife. c = " + c);
while (d < 5) {
if (d == 3) {
d++;
System.out.println("- Innere Schleife. Continue-Anweisung Label.");
continue labelContinueSchleife;
}
System.out.println("- Innere Schleife. d = " + d);
d++;
}
c++;
d = 1;
}
System.out.println();
c = 1;
d = 1;
labelBreakSchleife: while (c < 5) {
System.out.println("- Aussere Schleife. c = " + c);
while (d < 5) {
if (d == 3) {
System.out.println("- Innere Schleife. Break-Anweisung Label.");
break labelBreakSchleife;
}
System.out.println("- Innere Schleife. d = " + d);
d++;
}
c++;
d = 1;
}
}
}Im oberen Teil des Codes (Zeile 12 bis 24) sind zwei normale while-Schleifen ineinander verschachtelt, die in jedem Durchlauf eine Zeichenkette mit dem aktuellen Schleifendurchlauf ausgeben.
Im mittleren Teil des Codes (Zeile 29 bis 49) sind dieselben while-Schleifen angegeben, jedoch wird in der inneren Schleife im dritten Schleifendurchlauf die continue-Anweisung mit dem Label labelContinueSchleife ausgeführt.
Dadurch springt das Programm sofort zum Ende des äußeren Schleifenkörpers, da die äußere Schleife das Label labelContinueSchleife trägt, und startet die äußere Schleife erneut.
Im unteren Teil des Codes (Zeile 54 bis 73) wird die break-Anweisung mit dem Label labelBreakSchleife in der äußeren Schleife ausgeführt. Dadurch wird beim Erreichen der break-Anweisung (im dritten Durchlauf) aus beiden Schleifen gesprungen.
In der Abbildung unten ist die Ausgabe des Programms in der Kommandozeile dargestellt.
