Boucle Java while et do...while

Java while et do...while Loop

Dans ce tutoriel, nous allons apprendre à utiliser les boucles while et do while en Java à l'aide d'exemples.

En programmation informatique, les boucles sont utilisées pour répéter un bloc de code. Par exemple, si vous souhaitez afficher un message 100 fois, vous pouvez utiliser une boucle. C'est juste un exemple simple; vous pouvez faire bien plus avec les boucles.

Dans le didacticiel précédent, vous avez découvert Java for loop. Ici, vous allez en savoir plus sur while et do...while boucles.

Boucle while Java

Java while La boucle est utilisée pour exécuter un code spécifique jusqu'à ce qu'une certaine condition soit remplie. La syntaxe du while boucle est :

while (testExpression) {
    // body of loop
}

Ici,

Un while boucle évalue la textExpression entre parenthèses () .
Si textExpression évalue à true , le code à l'intérieur du while boucle est exécutée.
La textExpression est à nouveau évalué.
Ce processus se poursuit jusqu'à ce que textExpression est false .
Lorsque textExpression évalue à false , la boucle s'arrête.

Pour en savoir plus sur les conditions, consultez les opérateurs relationnels et logiques Java.

Organigramme de la boucle while

Exemple 1 :Afficher les nombres de 1 à 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++;
    }
  }
}

Sortie

Voici comment fonctionne ce programme.

Itération	Variable	Condition :i <=n	Action
1er	`i = 1` `n = 5`	`true`	`1` est imprimé. `je` est porté à 2 .
2ème	`i = 2` `n = 5`	`true`	`2` est imprimé. `je` est porté à 3 .
3ème	`i = 3` `n = 5`	`true`	`3` est imprimé. `je` est porté à 4 .
4ème	`i = 4` `n = 5`	`true`	`4` est imprimé. `je` est porté à 5 .
5ème	`i = 5` `n = 5`	`true`	`5` est imprimé. `je` est porté à 6 .
6ème	`i = 6` `n = 5`	`false`	La boucle est terminée

Exemple 2 :Somme des nombres positifs uniquement

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

Sortie

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

Dans le programme ci-dessus, nous avons utilisé la classe Scanner pour recevoir les entrées de l'utilisateur. Ici, nextInt() prend une entrée entière de l'utilisateur.

Le while la boucle continue jusqu'à ce que l'utilisateur entre un nombre négatif. A chaque itération, le nombre saisi par l'utilisateur est ajouté au sum variables.

Lorsque l'utilisateur entre un nombre négatif, la boucle se termine. Enfin, la somme totale s'affiche.

Boucle Java do...while

Le do...while La boucle est similaire à la boucle while. Cependant, le corps de do...while La boucle est exécutée une fois avant que l'expression de test ne soit vérifiée. Par exemple,

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

Ici,

Le corps de la boucle est exécuté en premier. Puis le textExpression est évalué.
Si textExpression évalue à true , le corps de la boucle à l'intérieur du do l'instruction est exécutée à nouveau.
La textExpression est évalué une fois de plus.
Si textExpression évalue à true , le corps de la boucle à l'intérieur du do l'instruction est exécutée à nouveau.
Ce processus se poursuit jusqu'à ce que textExpression évalue à false . Puis la boucle s'arrête.

Organigramme de la boucle do...while

Voyons le fonctionnement de do...while boucle.

Exemple 3 :Afficher les nombres de 1 à 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);
  }
}

Sortie

Voici comment fonctionne ce programme.

Itération	Variable	Condition :i <=n	Action
	`i = 1` `n = 5`	non coché	`1` est imprimé. `je` est porté à 2 .
1er	`i = 2` `n = 5`	`true`	`2` est imprimé. `je` est porté à 3 .
2ème	`i = 3` `n = 5`	`true`	`3` est imprimé. `je` est porté à 4 .
3ème	`i = 4` `n = 5`	`true`	`4` est imprimé. `je` est porté à 5 .
4ème	`i = 5` `n = 5`	`true`	`6` est imprimé. `je` est porté à 6 .
5ème	`i = 6` `n = 5`	`false`	La boucle est terminée

Exemple 4 :Somme de nombres positifs

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

Sortie 1

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

Ici, l'utilisateur entre un nombre positif, ce nombre est ajouté à la somme variable. Et ce processus continue jusqu'à ce que le nombre soit négatif. Lorsque le nombre est négatif, la boucle se termine et affiche la somme sans ajouter le nombre négatif.

Sortie 2

Enter a number
-8
Sum is 0

Ici, l'utilisateur entre un nombre négatif. La condition de test sera false mais le code à l'intérieur de la boucle s'exécute une fois.

Boucle while infinie

Si la condition d'une boucle est toujours true , la boucle s'exécute pendant une infinité de temps (jusqu'à ce que la mémoire soit pleine). Par exemple,

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

Voici un exemple d'infini do...while boucle.

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

Dans les programmes ci-dessus, le textExpression est toujours true . Par conséquent, le corps de la boucle s'exécutera pendant des durées infinies.

boucles for et while

Le for La boucle est utilisée lorsque le nombre d'itérations est connu. Par exemple,

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

Et while et do...while les boucles sont généralement utilisées lorsque le nombre d'itérations est inconnu. Par exemple,

while (condition) {
    // body of loop
}

Java pour chaque boucle Déclaration de rupture Java

Java