Java while en do...while Loop

In deze tutorial zullen we leren hoe we while en do while loop in Java kunnen gebruiken met behulp van voorbeelden.

Bij computerprogrammering worden lussen gebruikt om een codeblok te herhalen. Wil je bijvoorbeeld een bericht 100 keer laten zien, dan kun je een lus gebruiken. Het is maar een simpel voorbeeld; je kunt veel meer bereiken met loops.

In de vorige zelfstudie hebt u geleerd over Java for loop. Hier leer je over while en do...while lussen.

Java while-lus

Java while loop wordt gebruikt om een specifieke code uit te voeren totdat aan een bepaalde voorwaarde is voldaan. De syntaxis van de while lus is:

while (testExpression) {
    // body of loop
}

Hier,

Een while loop evalueert de textExpression tussen haakjes () .
Als de textExpression evalueert tot true , de code binnen de while lus wordt uitgevoerd.
De textExpression wordt opnieuw geëvalueerd.
Dit proces gaat door tot de textExpression is false .
Als de textExpression evalueert tot false , stopt de lus.

Ga voor meer informatie over de voorwaarden naar Java relationele en logische operatoren.

Stroomdiagram van while-lus

Voorbeeld 1:Toon getallen van 1 tot 5

// 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++;
    }
  }
}

Uitvoer

Hier is hoe dit programma werkt.

Iteratie	Variabele	Conditie:i <=n	Actie
1e	`i = 1` `n = 5`	`true`	`1` wordt afgedrukt. `ik` wordt verhoogd tot 2 .
2e	`i = 2` `n = 5`	`true`	`2` wordt afgedrukt. `ik` wordt verhoogd tot 3 .
3e	`i = 3` `n = 5`	`true`	`3` wordt afgedrukt. `ik` wordt verhoogd tot 4 .
4e	`i = 4` `n = 5`	`true`	`4` wordt afgedrukt. `ik` wordt verhoogd tot 5 .
5e	`i = 5` `n = 5`	`true`	`5` wordt afgedrukt. `ik` wordt verhoogd tot 6 .
6e	`i = 6` `n = 5`	`false`	De lus wordt beëindigd

Voorbeeld 2:Alleen som van positieve getallen

// 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();
  }
}

Uitvoer

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

In het bovenstaande programma hebben we de Scanner-klasse gebruikt om input van de gebruiker te krijgen. Hier, nextInt() neemt gehele invoer van de gebruiker.

De while lus gaat door totdat de gebruiker een negatief getal invoert. Tijdens elke iteratie wordt het door de gebruiker ingevoerde nummer toegevoegd aan de sum variabel.

Wanneer de gebruiker een negatief getal invoert, wordt de lus beëindigd. Ten slotte wordt het totale bedrag weergegeven.

Java do...while-lus

De do...while lus is vergelijkbaar met while-lus. De hoofdtekst van do...while lus wordt eenmaal uitgevoerd voordat de testexpressie wordt gecontroleerd. Bijvoorbeeld,

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

Hier,

De hoofdtekst van de lus wordt eerst uitgevoerd. Dan de textExpression wordt geëvalueerd.
Als de textExpression evalueert tot true , de body van de lus binnen de do instructie wordt opnieuw uitgevoerd.
De textExpression wordt opnieuw geëvalueerd.
Als de textExpression evalueert tot true , de hoofdtekst van de lus binnen de do instructie wordt opnieuw uitgevoerd.
Dit proces gaat door tot de textExpression evalueert tot false . Dan stopt de lus.

Stroomdiagram van do...while-lus

Laten we eens kijken hoe do...while . werkt lus.

Voorbeeld 3:Toon getallen van 1 tot 5

// 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);
  }
}

Uitvoer

Hier is hoe dit programma werkt.

Iteratie	Variabele	Conditie:i <=n	Actie
	`i = 1` `n = 5`	niet aangevinkt	`1` wordt afgedrukt. `ik` wordt verhoogd tot 2 .
1e	`i = 2` `n = 5`	`true`	`2` wordt afgedrukt. `ik` wordt verhoogd tot 3 .
2e	`i = 3` `n = 5`	`true`	`3` wordt afgedrukt. `ik` wordt verhoogd tot 4 .
3e	`i = 4` `n = 5`	`true`	`4` wordt afgedrukt. `ik` wordt verhoogd tot 5 .
4e	`i = 5` `n = 5`	`true`	`6` wordt afgedrukt. `ik` wordt verhoogd tot 6 .
5e	`i = 6` `n = 5`	`false`	De lus wordt beëindigd

Voorbeeld 4:Som van positieve getallen

// 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();
  }
}

Uitgang 1

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

Hier voert de gebruiker een positief getal in, dat getal wordt opgeteld bij de som variabel. En dit proces gaat door totdat het getal negatief is. Als het getal negatief is, wordt de lus beëindigd en wordt de som weergegeven zonder het negatieve getal toe te voegen.

Uitgang 2

Enter a number
-8
Sum is 0

Hier voert de gebruiker een negatief getal in. De testconditie is false maar de code in de lus wordt één keer uitgevoerd.

Oneindige while-lus

Als de voorwaarde van een lus is altijd true , loopt de lus oneindig lang (totdat het geheugen vol is). Bijvoorbeeld,

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

Hier is een voorbeeld van een oneindige do...while lus.

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

In de bovenstaande programma's is de textExpression is altijd true . Daarom zal de loop-body oneindig lang draaien.

voor en while-lussen

De for lus wordt gebruikt wanneer het aantal iteraties bekend is. Bijvoorbeeld,

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

En while en do...while loops worden over het algemeen gebruikt wanneer het aantal iteraties onbekend is. Bijvoorbeeld,

while (condition) {
    // body of loop
}

Java voor elke lus Java-onderbrekingsverklaring

Java