Java while und do...while Schleife

In diesem Tutorial lernen wir anhand von Beispielen, wie man while und do while loop in Java verwendet.

Bei der Computerprogrammierung werden Schleifen verwendet, um einen Codeblock zu wiederholen. Wenn Sie beispielsweise eine Nachricht 100 Mal anzeigen möchten, können Sie eine Schleife verwenden. Es ist nur ein einfaches Beispiel; Mit Schleifen können Sie viel mehr erreichen.

Im vorherigen Tutorial haben Sie etwas über die Java-For-Schleife gelernt. Hier erfahren Sie etwas über while und do...while Schleifen.

Java-While-Schleife

Java while Schleife wird verwendet, um einen bestimmten Code auszuführen, bis eine bestimmte Bedingung erfüllt ist. Die Syntax der while Schleife ist:

while (testExpression) {
    // body of loop
}

Hier,

A while loop wertet den textExpression aus innerhalb der Klammer () .
Wenn der textExpression ergibt true , der Code innerhalb von while Schleife wird ausgeführt.
Der Textausdruck wird erneut ausgewertet.
Dieser Vorgang wird bis zum textExpression fortgesetzt ist false .
Wenn der textExpression ergibt false , die Schleife stoppt.

Weitere Informationen zu den Bedingungen finden Sie unter Relationale und logische Java-Operatoren.

Flussdiagramm der While-Schleife

Beispiel 1:Zahlen von 1 bis 5 anzeigen

// Program to display numbers from 1 to 5

class Main {
  public static void main(String[] args) {

    // declare variables
    int i = 1, n = 5;

    // while loop from 1 to 5
    while(i <= n) {
      System.out.println(i);
      i++;
    }
  }
}

Ausgabe

So funktioniert dieses Programm.

Iteration	Variable	Bedingung:i <=n	Aktion
1.	`i = 1` `n = 5`	`true`	`1` wird gedruckt. `ich` wird auf 2 erhöht .
2.	`i = 2` `n = 5`	`true`	`2` wird gedruckt. `ich` wird auf 3 erhöht .
3.	`i = 3` `n = 5`	`true`	`3` wird gedruckt. `ich` wird auf 4 erhöht .
4.	`i = 4` `n = 5`	`true`	`4` wird gedruckt. `ich` wird auf 5 erhöht .
5.	`i = 5` `n = 5`	`true`	`5` wird gedruckt. `ich` wird auf 6 erhöht .
6.	`i = 6` `n = 5`	`false`	Die Schleife wird beendet

Beispiel 2:Nur Summe positiver Zahlen

// Java program to find the sum of positive numbers
import java.util.Scanner;

class Main {
  public static void main(String[] args) {
      
    int sum = 0;

    // create an object of Scanner class
    Scanner input = new Scanner(System.in);

    // take integer input from the user
    System.out.println("Enter a number");
    int number = input.nextInt();
	   
    // while loop continues 
    // until entered number is positive
    while (number >= 0) {
      // add only positive numbers
      sum += number;

      System.out.println("Enter a number");
      number = input.nextInt();
    }
	   
    System.out.println("Sum = " + sum);
    input.close();
  }
}

Ausgabe

Enter a number
25
Enter a number
9
Enter a number
5
Enter a number
-3
Sum = 39

Im obigen Programm haben wir die Scanner-Klasse verwendet, um Eingaben vom Benutzer entgegenzunehmen. Hier, nextInt() nimmt ganzzahlige Eingaben vom Benutzer entgegen.

Der while Die Schleife wird fortgesetzt, bis der Benutzer eine negative Zahl eingibt. Bei jeder Iteration wird die vom Benutzer eingegebene Zahl zum sum hinzugefügt Variable.

Wenn der Benutzer eine negative Zahl eingibt, wird die Schleife beendet. Abschließend wird die Gesamtsumme angezeigt.

Java do...while-Schleife

Der do...while Die Schleife ähnelt der While-Schleife. Der Körper von do...while Schleife wird einmal ausgeführt, bevor der Testausdruck geprüft wird. Zum Beispiel

do {
    // body of loop
} while(textExpression);

Hier,

Zuerst wird der Rumpf der Schleife ausgeführt. Dann der textExpression ausgewertet.
Wenn der textExpression ergibt true , der Körper der Schleife innerhalb des do Anweisung wird erneut ausgeführt.
Der Textausdruck erneut ausgewertet.
Wenn der textExpression ergibt true , der Körper der Schleife innerhalb von do Anweisung wird erneut ausgeführt.
Dieser Vorgang wird bis zum textExpression fortgesetzt ergibt false . Dann stoppt die Schleife.

Flussdiagramm der do...while-Schleife

Sehen wir uns die Funktionsweise von do...while an Schleife.

Beispiel 3:Zahlen von 1 bis 5 anzeigen

// Java Program to display numbers from 1 to 5

import java.util.Scanner;

// Program to find the sum of natural numbers from 1 to 100.

class Main {
  public static void main(String[] args) {

    int i = 1, n = 5;

    // do...while loop from 1 to 5
    do {
      System.out.println(i);
      i++;
    } while(i <= n);
  }
}

Ausgabe

So funktioniert dieses Programm.

Iteration	Variable	Bedingung:i <=n	Aktion
	`i = 1` `n = 5`	nicht geprüft	`1` wird gedruckt. `ich` wird auf 2 erhöht .
1.	`i = 2` `n = 5`	`true`	`2` wird gedruckt. `ich` wird auf 3 erhöht .
2.	`i = 3` `n = 5`	`true`	`3` wird gedruckt. `ich` wird auf 4 erhöht .
3.	`i = 4` `n = 5`	`true`	`4` wird gedruckt. `ich` wird auf 5 erhöht .
4.	`i = 5` `n = 5`	`true`	`6` wird gedruckt. `ich` wird auf 6 erhöht .
5.	`i = 6` `n = 5`	`false`	Die Schleife wird beendet

Beispiel 4:Summe positiver Zahlen

// Java program to find the sum of positive numbers
import java.util.Scanner;

class Main {
  public static void main(String[] args) {
      
    int sum = 0;
    int number = 0;

    // create an object of Scanner class
    Scanner input = new Scanner(System.in);
	   
    // do...while loop continues 
    // until entered number is positive
    do {
      // add only positive numbers
      sum += number;
      System.out.println("Enter a number");
      number = input.nextInt();
    } while(number >= 0); 
	   
    System.out.println("Sum = " + sum);
    input.close();
  }
}

Ausgang 1

Enter a number
25
Enter a number
9
Enter a number
5
Enter a number
-3
Sum = 39

Hier gibt der Benutzer eine positive Zahl ein, diese Zahl wird zur Summe addiert Variable. Und dieser Prozess wird fortgesetzt, bis die Zahl negativ ist. Wenn die Zahl negativ ist, wird die Schleife beendet und die Summe angezeigt, ohne die negative Zahl hinzuzufügen.

Ausgang 2

Enter a number
-8
Sum is 0

Hier gibt der Benutzer eine negative Zahl ein. Die Testbedingung ist false aber der Code innerhalb der Schleife wird einmal ausgeführt.

Endlose While-Schleife

Wenn die Bedingung einer Schleife ist immer true , läuft die Schleife unendlich oft (bis der Speicher voll ist). Zum Beispiel

// infinite while loop
while(true){
    // body of loop
}

Hier ist ein Beispiel für ein unendliches do...while Schleife.

// infinite do...while loop
int count = 1;
do {
   // body of loop
} while(count == 1)

In den obigen Programmen ist die textExpression ist immer true . Daher läuft der Schleifenkörper unendlich lange.

for- und while-Schleifen

Der for Schleife wird verwendet, wenn die Anzahl der Iterationen bekannt ist. Zum Beispiel

for (let i = 1; i <=5; ++i) {
   // body of loop
}

Und while und do...while Schleifen werden im Allgemeinen verwendet, wenn die Anzahl der Iterationen unbekannt ist. Zum Beispiel

while (condition) {
    // body of loop
}

Java for-each-Schleife Java-break-Anweisung

Java