Schleifen in Programmiersprachen sind eine Funktion, die die wiederholte Ausführung einer Reihe von Anweisungen/Funktionen erleichtert, während eine Bedingung als wahr ausgewertet wird. Java bietet drei Möglichkeiten zum Ausführen der Schleifen. Obwohl alle Möglichkeiten eine ähnliche Grundfunktionalität bieten, unterscheiden sie sich in ihrer Syntax und Bedingungsprüfungszeit.
Java bietet drei Arten von bedingten Anweisungen. Der zweite Typ ist die Schleifenanweisung.
- while-Schleife: Eine While-Schleife ist eine Kontrollflussanweisung, die es ermöglicht, Code basierend auf einer bestimmten booleschen Bedingung wiederholt auszuführen. Die while-Schleife kann man sich als sich wiederholende if-Anweisung vorstellen.
Syntax :
while (boolean condition) { loop statements... }> Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >int> i=>0>;> >while> (i<=>10>)> >{> >System.out.println(i);> >i++;> >}> >}> }> |
>
>Ausgabe
0 1 2 3 4 5 6 7 8 9 10>
- Flussdiagramm:
- 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 es auch genannt Eintrittsregelkreis
- 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.
- for-Schleife: Die for-Schleife bietet eine präzise Möglichkeit, die Schleifenstruktur zu schreiben. Im Gegensatz zu einer While-Schleife verbraucht eine for-Anweisung die Initialisierung, Bedingung und Inkrementierung/Dekrementierung in einer Zeile und sorgt so für eine kürzere, leicht zu debuggende Schleifenstruktur.
Syntax:
for (initialization condition; testing condition;increment/decrement) { statement(s) }> Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >for> (>int> i=>0>;i<=>10>;i++)> >{> >System.out.println(i);> >}> >}> }> |
>
Java-String ersetzen
>Ausgabe
0 1 2 3 4 5 6 7 8 9 10>
- Flussdiagramm:
- 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: Wird zum Testen der Beendigungsbedingung für eine Schleife verwendet. Es muss einen booleschen Wert zurückgeben. Es ist auch ein Eintrittskontrollschleife da die Bedingung vor der Ausführung der Schleifenanweisungen überprüft wird. Anweisungsausführung: 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. Schleifenbeendigung: Wenn die Bedingung falsch wird, wird die Schleife beendet und markiert damit das Ende ihres Lebenszyklus.
- tun, während: Die do while-Schleife ähnelt der while-Schleife mit dem einzigen Unterschied, dass sie nach der Ausführung der Anweisungen die Bedingung prüft und daher ein Beispiel dafür ist Verlassen Sie den Regelkreis.
Syntax:
do { statements.. } while (condition);> Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >int> i=>0>;> >do> >{> >System.out.println(i);> >i++;> >}>while>(i<=>10>);> >}> }> |
>
>Ausgabe
0 1 2 3 4 5 6 7 8 9 10>
- Flussdiagramm:
- Die do while-Schleife beginnt mit der Ausführung der Anweisung(en). 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 die Auswertung „true“ ergibt, 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.
Fallstricke von Schleifen
- Endlosschleife: Einer der häufigsten Fehler bei der Implementierung jeglicher Art von Schleife besteht darin, dass sie möglicherweise nie beendet wird, d. h. die Schleife läuft unendlich lange. Dies geschieht, wenn die Bedingung aus irgendeinem Grund fehlschlägt. Beispiele: Unendliche for-Schleife:
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >for> (;;) {> >}> >}> }> |
>
>
unendliche While-Schleife:
Java
wie die Schule erfunden wurde
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >while> (>true>)> >{> >// statement> >}> > >}> }> |
>
>
Java
//Java program to illustrate various pitfalls.> public> class> LooppitfallsDemo> {> >public> static> void> main(String[] args)> >{> >// infinite loop because condition is not apt> >// condition should have been i>0.> >for> (>int> i =>5>; i !=>0>; i -=>2>)> >{> >System.out.println(i);> >}> >int> x =>5>;> >// infinite loop because update statement> >// is not provided.> >while> (x ==>5>)> >{> >System.out.println('In the loop');> >}> >}> }> |
String-Builder
>
>
Eine weitere Gefahr besteht darin, dass Sie möglicherweise durch eine Schleife etwas zu Ihrem Sammlungsobjekt hinzufügen und möglicherweise nicht mehr genügend Speicher vorhanden ist. Wenn Sie versuchen, das folgende Programm auszuführen, wird nach einiger Zeit die Ausnahme „Nicht genügend Arbeitsspeicher“ ausgelöst.
Java
//Java program for out of memory exception.> import> java.util.ArrayList;> public> class> Integer1> {> >public> static> void> main(String[] args)> >{> >ArrayList ar =>new> ArrayList();> >for> (>int> i =>0>; i { ar.add(i); } } }> |
>
>
Ausgabe:
Exception in thread 'main' java.lang.OutOfMemoryError: Java heap space at java.util.Arrays.copyOf(Unknown Source) at java.util.Arrays.copyOf(Unknown Source) at java.util.ArrayList.grow(Unknown Source) at java.util.ArrayList.ensureCapacityInternal(Unknown Source) at java.util.ArrayList.add(Unknown Source) at article.Integer1.main(Integer1.java:9)>
Verschachtelte Schleife:
Unter einer verschachtelten Schleife versteht man eine Schleifenanweisung innerhalb einer anderen Schleifenanweisung.
Es gibt verschiedene Kombinationen der Schleifenverwendung für Schleife, während Schleife, tun-während Schleife.
Bsp. 1 Verschachtelte for-Schleife
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >for>(>int> i =>0>; i <>3>; i++){> >for>(>int> j =>0>; j <>2>; j++){> >System.out.println(i);> >}> >System.out.println();> >}> >}> }> |
>
>Ausgabe
0 0 1 1 2 2>
Bsp.2 Verschachtelte while-Schleife
Java
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> i =>1>, j =>1>;> >while> (i <=>3>) {> >while> (j <=>3>) {> >System.out.print(j);> >j++;> >}> >i++;> >System.out.println(>''>);> >j =>1>;> >}> >}> }> |
>
>Ausgabe
123 123 123>
Bsp.3 Verschachtelte do-while-Schleife
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> row =>1>, column =>1>;> >int> x;> >do> {> >x =>4>;> >do> {> >System.out.print(>''>);> >x--;> >}>while> (x>= Zeile);> >column =>1>;> >do> {> >System.out.print(column +>' '>);> >column++;> >}>while> (column <=>5>);> >System.out.println(>' '>);> >row++;> >}>while> (row <=>5>);> >}> }> |
>
Fmovies Indien
>Ausgabe
1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5>
Bsp.4 Verschachtelte while- und for-Schleife
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> weeks =>3>;> >int> days =>7>;> >int> i =>1>;> >// outer loop> >while> (i <= weeks) {> >System.out.println(>'Week: '> + i);> >// inner loop> >for> (>int> j =>1>; j <= days; ++j) {> >System.out.println(>' Days: '> + j);> >}> >++i;> >}> >}> }> |
>
>Ausgabe
Week: 1 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7 Week: 2 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7 Week: 3 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7>