Schleifen in der Programmierung ermöglichen die mehrfache Ausführung einer Reihe von Anweisungen basierend auf einer Bedingung. In Java gibt es drei Arten von Schleifen, die im Folgenden erläutert werden:

1. for-Schleife

Die for-Schleife wird verwendet, wenn wir die Anzahl der Iterationen kennen (wir wissen, wie oft wir eine Aufgabe wiederholen möchten). Die for-Anweisung enthält die Initialisierungsbedingung und das Inkrementieren/Dekrementieren in einer Zeile. 

Beispiel: Das folgende Java-Programm demonstriert eine for-Schleife, die Zahlen von 0 bis 10 in einer einzigen Zeile druckt.

// Java program to demonstrates the working of for loop import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i <= 10; i++) {  System.out.print(i + ' ');  }  } } 

0 1 2 3 4 5 6 7 8 9 10 

Syntax:

for (Initialisierung; Bedingung; Inkrement/Dekrement) {

// Code, der ausgeführt werden soll

}

Das Bild unten zeigt das Flussdiagramm einer for-Schleife:

• Initialisierungsbedingung : Hier initialisieren wir die verwendete Variable. Es markiert den Beginn einer for-Schleife. Es kann eine bereits deklarierte Variable verwendet werden oder eine Variable kann nur lokal für die Schleife deklariert werden.
• Testbedingung: Es wird zum Testen der Beendigungsbedingung für eine Schleife verwendet. Es muss einen booleschen Wert zurückgeben. Es handelt sich auch um eine Eingangskontrollschleife, da die Bedingung vor der Ausführung der Schleifenanweisungen überprüft wird.
• Ausführung der Anweisung : Sobald die Bedingung als wahr ausgewertet wird, werden die Anweisungen im Schleifenkörper ausgeführt.
• Inkrementieren/Dekrementieren : Wird zum Aktualisieren der Variablen für die nächste Iteration verwendet.
• Schleifenabschluss :Wenn die Bedingung falsch wird, wird die Schleife beendet und markiert damit das Ende ihres Lebenszyklus.

Notiz : Es gibt eine andere Form der for-Schleife, bekannt als Verbesserte for-Schleife oder (für jede Schleife).

Regisseur Karan Johar

Erweiterte for-Schleife (für jeden)

Diese Schleife wird zum Durchlaufen von Arrays oder Sammlungen verwendet.

Beispiel : Das folgende Java-Programm demonstriert eine erweiterte for-Schleife (für jede Schleife), um ein Array zu durchlaufen und Namen auszugeben.

// Java program to demonstrate  // the working of for each loop import java.io.*; class Geeks {  public static void main(String[] args)  {  String[] names = { 'Sweta' 'Gudly' 'Amiya' };  for (String name : names) {  System.out.println('Name: ' + name);  }  } } 

Name: Sweta Name: Gudly Name: Amiya 

Syntax:

for (dataType-Variable: arrayOrCollection) {

// Code, der ausgeführt werden soll

}

2. while-Schleife

Eine While-Schleife wird verwendet, wenn wir die Bedingung überprüfen möchten, bevor wir den Schleifenkörper ausführen.

Beispiel: Das folgende Java-Programm demonstriert eine While-Schleife, die Zahlen von 0 bis 10 in einer einzigen Zeile ausgibt.

// Java program to demonstrates  // the working of while loop import java.io.*; class Geeks {  public static void main(String[] args)  {  int i = 0;  while (i <= 10) {  System.out.print(i + ' ');  i++;  }  } } 

0 1 2 3 4 5 6 7 8 9 10 

Syntax:

while (Bedingung) {

// Code, der ausgeführt werden soll

}

Das folgende Bild zeigt das Flussdiagramm einer While-Schleife:

Vergleichen Sie Zeichenfolgen Java

• Die While-Schleife beginnt mit der Überprüfung der booleschen Bedingung. Wenn die Auswertung „true“ ergibt, werden die Anweisungen im Schleifenkörper ausgeführt, andernfalls wird die erste Anweisung nach der Schleife ausgeführt. Aus diesem Grund wird er auch Eintrittsregelkreis genannt
• Sobald die Bedingung als wahr ausgewertet wird, werden die Anweisungen im Schleifenkörper ausgeführt. Normalerweise enthalten die Anweisungen einen Aktualisierungswert für die Variable, die für die nächste Iteration verarbeitet wird.
• Wenn die Bedingung falsch wird, wird die Schleife beendet, was das Ende ihres Lebenszyklus markiert.

3. do-while-Schleife

Die do-while-Schleife stellt sicher, dass der Codeblock ausgeführt wird mindestens einmal bevor Sie den Zustand prüfen.

Beispiel : Das folgende Java-Programm demonstriert eine Do-While-Schleife, die Zahlen von 0 bis 10 in einer einzigen Zeile ausgibt.

// Java program to demonstrates  // the working of do-while loop import java.io.*; class Geeks {  public static void main(String[] args)  {  int i = 0;  do {  System.out.print(i + ' ');  i++;  } while (i <= 10);  } } 

0 1 2 3 4 5 6 7 8 9 10 

Syntax:

Tun {

// Code, der ausgeführt werden soll

} while (Bedingung);

Das folgende Bild zeigt das Flussdiagramm einer Do-While-Schleife:

• Die do while-Schleife beginnt mit der Ausführung der Anweisung. Es erfolgt keine erstmalige Prüfung eines Zustandes.
• Nach der Ausführung der Anweisungen und der Aktualisierung des Variablenwerts wird die Bedingung auf einen wahren oder falschen Wert überprüft. Wenn es als wahr ausgewertet wird, beginnt die nächste Iteration der Schleife.
• Wenn die Bedingung falsch wird, wird die Schleife beendet, was das Ende ihres Lebenszyklus markiert.
• Es ist wichtig zu beachten, dass die Do-While-Schleife ihre Anweisungen mindestens einmal ausführt, bevor eine Bedingung überprüft wird, und daher ein Beispiel für eine Exit-Kontrollschleife ist.

Häufige Schleifenfehler und wie man sie vermeidet

Wenn Schleifen nicht korrekt verwendet werden, können sie zu Fallstricken und Fehlern führen, die die Lesbarkeit und Funktionalität des Codes beeinträchtigen. Im Folgenden sind einige häufige Fallstricke von Schleifen aufgeführt:

1. Endlosschleifen

Dies ist einer der häufigsten Fehler bei der Implementierung jeglicher Art von Schleife. Er besteht darin, dass die Schleife möglicherweise nie beendet wird, d. h. die Schleife läuft unendlich lange. Dies geschieht, wenn die Bedingung aus irgendeinem Grund fehlschlägt.

Arten von Endlosschleifen:

• unendliche for-Schleife
• unendliche While-Schleife

Beispiel: Hier demonstrieren beide Beispiele die Endlosschleifen.

// Java program to demonstrate  // the infinite for loop import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i < 5; i--) {  System.out.println(  'This loop will run forever');  }  } } 

// Java Program to demonstrate  // the infinite while loop import java.io.*; class Geeks {  public static void main(String[] args)  {  while(true)  {  System.out.println(  'Basic example of infinte loop');  }  } } 

Ausgabe: Wenn Sie beide oben genannten Codes ausführen, erhalten Sie die Fehlermeldung TLE (Time Limit Exceeded).

2. Off-by-One-Fehler

Off-by-One-Fehler werden verursacht, wenn die Schleife einmal mehr oder weniger oft als gewünscht ausgeführt wird. Es passiert grundsätzlich, wenn die Schleifenbedingung nicht richtig eingestellt ist.

Beispiel : Das folgende Java-Programm zeigt einen Off-by-One-Fehler, bei dem die Schleife sechsmal ausgeführt wird und wir erwartet haben, dass sie fünfmal ausgeführt wird.

// Java Program to demonstrates Off-by-One Errors import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i <= 5; i++) {  System.out.print(i + ' ');  }  } } 

3. Schleifenvariablen innerhalb der Schleife ändern

Wenn wir die Schleifenbedingung (wie i) innerhalb der Schleife ändern, kann dies dazu führen, dass die Schleife bestimmte Iterationen überspringt oder sich auf eine Weise verhält, die wir nicht erwartet haben. Dies kann zu Fehlern oder unerwartetem Verhalten führen.

Beispiel : Das folgende Java-Programm demonstriert das Ändern der Schleifenvariablen innerhalb der Schleife, was dazu führt, dass die Schleife bestimmte Iterationen überspringt und sich unerwartet verhält.

// Java program demonstrates  // modification in i variable import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i < 5; i++) {  if (i == 2) {    // Modifies the loop variable and skips  // the next iteration  i++;  }  System.out.println(i);  }  } } 

4. Leerer Schleifenkörper

Ein leerer Schleifenkörper tritt auf, wenn eine Schleife zur Iteration geschrieben wird, aber innerhalb der Schleife keine Operationen ausführt. Das Ausführen einer Schleife ohne nützliche Operationen darin kann verwirrend sein.

Beispiel: Das folgende Java-Programm demonstriert den leeren Schleifenkörper.

// Java program to demonstrates Empty loop body import java.io.*; class Geeks {  public static void main(String[] args)  {  for (int i = 0; i < 10; i++) {    // Empty body no operations  }  } } 

Hierzu wird keine Ausgabe generiert, da der Schleifenkörper leer ist.

Java-Stacks

Übersichtstabelle

Verwandte Beiträge:

• for-Schleife
• while-Schleife
• do-while-Schleife