Java unterstützt das Konzept der Schleifen, um bestimmte Anweisungen mehrfach auszuführen. Java Schleifen führen ein bestimmtes Codesegment eine endliche Anzahl von Malen aus, bis die angegebene Bedingung erfüllt ist. Java Schleifen bieten zahlreiche Funktionen wie die Wiederverwendbarkeit des Codes, Zeitersparnis und geringere Fehleranfälligkeit durch Automatisierung. Dabei gibt es vier Arten von Java Schleifen: for-Schleife, erweiterte for-Schleife (for-each-Schleife), while-Schleife und do-while-Schleife.
In diesem Beitrag werden die verschiedenen Arten von Java Schleifen und ihr Kontrollfluss anhand einiger geeigneter Beispiele erläutert. Also, fangen wir an!
Die Java for-Schleife
Die Java for-Schleife ist einfach, leicht verständlich und eine der am häufigsten verwendeten Schleifen. Sie ist sehr empfehlenswert in einem Szenario, in dem eine Anzahl von Iterationen festgelegt ist, beziehungsweise die genaue Anzahl der Iterationen/Wiederholungen bereits bekannt ist.
Syntax der Java for Schleife
Der unten stehende Ausschnitt veranschaulicht die grundlegende Syntax der Java for-Schleife:
for (zaehlerVariableInitialisieren; bedingung; zaehlerErhoehen / zaehlerVerringern) {
// Schleifenrumpf / Schleifenkörper
}
Die Java-for-Schleife benötigt drei Ausdrücke:
- Initialisierung: Sie gibt den Anfangspunkt der Schleife an.
- Bedingung: Sie bestimmt, wann die Ausführung der Schleife beendet werden soll. Dabei ist der Rückgabewert der Prüfung ein Java Boolean, nur wenn die Bedingung true ist, wird die Schleife betreten.
- Inkrementieren/Dekrementieren: bestimmt, ob der Wert des Zählers nach jeder Wiederholung inkrementiert oder dekrementiert werden soll.
Dieser Teil einer Schleife wird Schleifenkopf genannt. In ebendiesem stellen wir also unsere Bedingungen auf. Jede Iteration, wo die gegebene Bedingung noch gilt (beziehungsweise True ist), werden die Anweisungen innerhalb des sogenannten Schleifenrumpf / Schleifenkörpers ausgeführt.
Beispiel
In diesem Beispiel soll die Summe der ersten zehn Zahlen mit Hilfe einer Java for-Schleife ermittelt werden:
// Java Schleifen: Die for-Schleife
public class JavaForSchleife {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 10; i++) {
sum = sum + i;
}
System.out.println("Summe: " + sum);
}
}
Der vollständige Code mit der entsprechenden Ausgabe ist im folgenden Ausschnitt dargestellt:
Die Ausgabe zeigt also die korrekte Funktionsweise der Java for-loop.
Die Java forEach-Schleife
Die for-each-Schleife in Java wird auch als erweiterte for-Schleife bezeichnet und dient zum Durchlaufen von Java-Arrays und -Sammlungen wie LinkedList, Arraylist usw. Die for-each-Schleife nimmt keine Abbruchbedingung an. Stattdessen durchläuft sie jeden einzelnen Eintrag in den Arrays, Listen usw.
Syntax
Betrachten wir den folgenden Codeblock, um die grundlegende Syntax der Java for-each-Schleife zu verstehen:
for (datentyp nameDerVariable: nameDesArrays) {
// Schleifenkörper / Schleifenrumpf
}
Die for-each-Schleife nimmt die folgenden Ausdrücke an: den Java Datentypen, der den Typ einer Variablen bestimmt, einen benutzerdefinierten Variablennamen und den Namen des zu durchlaufenden Arrays.
Beispiel
In diesem Beispiel erstellen wir ein Array mit fünf Elementen und durchlaufen dessen Elemente mit einer for-each-Schleife:
// Java Schleifen: forEach
public class JavaForEach {
public static void main(String[] args) {
String[] name = {
"Simon",
"Claudia",
"Marco",
"Markus",
"Johanna"
};
for (String str: name) {
System.out.println(str);
}
}
}
Das obige Codeschnipsel erzeugt die folgende Ausgabe:
Der obige Ausschnitt zeigt, dass die for-each-Schleife jedes Element des Arrays durchläuft.
Die Java while-Schleife
Die while-Schleife in Java nimmt einen Ausdruck/eine Bedingung und wiederholt den damit verbundenen Schleifenkörper, solang die Bedingung erfüllt ist. In Java wird die while-Schleife häufig verwendet, wenn die Anzahl der Wiederholungen/Iterationen nicht festgelegt beziehungsweise nicht bekannt ist.
Syntax
Der folgende Ausschnitt zeigt die grundlegende Syntax der while-Schleife:
while (bedingung) {
// Schleifenkörper
// inkrementieren oder dekrementieren
// wichtig, ansonsten Endlosschleife
}
Anhand des obigen Ausschnitts können wir die unten aufgeführten Punkte beobachten:
- Die zu prüfende Bedingung oder der Ausdruck steht am Anfang.
- Wenn die Testbedingung wahr ist, wird der mit dieser Bedingung verbundene Code ausgeführt.
- Wenn die Testbedingung falsch ist, wird die Schleife abgebrochen.
- Wenn die angegebene Bedingung/der angegebene Ausdruck in der ersten Schleife falsch ist, wird der mit dieser Bedingung verbundene Code nie ausgeführt.
- Der Wert der Variablen muss innerhalb der Schleife inkrementiert oder dekrementiert werden; andernfalls wird der mit der Schleife verbundene Code unendlich oft ausgeführt. Das Phänomen wird auch als Endlosschleife bezeichnet.
Beispiel
Im folgenden Beispiel möchten wir bei jeder Iteration den Wert der Variable num hoch 3 nehmen. Schauen wir uns also an wie wir das implementieren könnten.
// Java Schleifen: Die while-Schleife
public class JavaLoops {
public static void main(String[] args) {
int num = 1;
while (num <= 5) {
System.out.println("Ursprünglicher Wert: " + num);
System.out.println("num hoch 3 ergibt: " + num * num * num);
num++;
}
}
}
Wir setzen den Anfangswert von num auf 1. Danach setzen wir die while-Schleife ein, die so lange ausgeführt wird, bis der Wert von num größer 5 wird. Wenn der Wert von num kleiner oder gleich 5 ist, wird der Schleifenkörper ausgeführt und der Würfel dieser Zahl gedruckt:
So funktioniert die while-Schleife in Java.
Die Java do-while-Schleife
Die do-while-Schleife ist im Wesentlichen identisch zu der Java while-Schleife; der einzige Unterschied zwischen ihnen ist, dass die do-while-Schleife unabhängig von der angegebenen Bedingung mindestens einmal ausgeführt wird.
Syntax
Hier ist die Syntax der do-while-Schleife:
do {
// Schleifenkörper / Schleifenrumpf
// inkrementieren / dekrementieren
} while (bedingung);
Der obige Ausschnitt zeigt, dass die Bedingung am Ende der Schleife eintritt.
Beispiel
Betrachten wir das folgende Beispiel, um ein grundlegendes Verständnis für die do-while-Schleife zu bekommen:
// Java Schleifen: Die do-while-Schleife
public class JavaLoops {
public static void main(String[] args) {
int num = 6;
do {
System.out.println("Ursprünglicher Wert: " + num);
System.out.println("num hoch 3 ergibt: " + num * num * num);
num++;
} while (num <= 5);
}
}
Diesmal ist der Anfangswert 6, während die Bedingung besagt, dass der Wert der Zählervariable num kleiner oder gleich 5 sein muss. Trotzdem wird die do-while-Schleife einmal ausgeführt:
So funktioniert die do-while-Schleife in Java.
Zusammenfassung: Java Schleifen
Schleifen in Java werden in Abhängigkeit von der Gültigkeit der angegebenen Bedingung ausgeführt. Alle Java Schleifen haben das gleiche Ziel, nämlich die mehrmalige Iteration eines Codesegments; es ist jedoch vorzuziehen, die for-Schleife bei einer festen Anzahl von Iterationen zu verwenden, die for-each-Schleife zu verwenden, um das gesamte Array oder die Liste zu durchlaufen, die while-Schleife zu verwenden, wenn die Anzahl der Iterationen nicht festgelegt ist, und die do-while-Schleife zu verwenden, wenn das Codesegment mindestens einmal ausgeführt werden muss. Wir hoffen wir konnten dir die Java Schleifen etwas näher bringen!
Schreibe einen Kommentar