Les boucles en Java – for, while et do-while

Les boucles en Java exécutent un code un nombre défini de fois jusqu’à ce que la condition spécifiée soit remplie.

La fréquence de répétition de la boucle est définie dans la condition de la boucle. En java ou dans les autres langages de programmations, il existe plusieurs types de boucles.

Afin de choisir la bonne boucle pour votre programme, les particularités des boucles doivent être connues et comprises.

La boucle for de Java

La boucle for de Java est simple, facile à comprendre et est l’une des boucles les plus couramment utilisées. Elle est souvent utilisée lorsque le nombre d’itérations est déterminé, ou le nombre exact d’itérations/répétitions est déjà connu.

for ( initialisation ; condition; incrémentation/décrémentation ) {  
    	    // le bloc de code de la boucle
    	}

La boucle for en Java nécessite trois expressions :

• L’initialisation : indique le point de départ de la boucle.
• La condition : détermine quand l’exécution de la boucle doit se terminer. La valeur de retour de la vérification est un booléen, la boucle ne s’exécute que si la condition est vraie.
• Incrémentation / Décrémentation : détermine si la valeur du compteur doit être incrémentée ou décrémentée après chaque itération.

Voici un exemple qui affiche les chiffres de 1 à 5.

class Test {

    public static void main(String[] args) {
    	int i;
    	for (i = 1; i <= 5; i++) {
    	   System.out.println(i);         
    	}
    }
}

Ce qui donne :

1
2
3
4
5

Prenons un autre exemple, nous allons utiliser la boucle for pour calculer la somme des dix premiers nombres.

class Test {

    public static void main(String[] args) {
    	int sum = 0;
    	for (int i = 1; i <= 10; i++) {
    	     sum = sum + i;
    	}
    	System.out.println("Somme: " + sum);
    }
}

Exécution du code :

Somme: 55

Notez que System.out.println("Somme: " + sum); est à l’extérieur du bloc de code de la boucle for. Essayez de le mettre à l’intérieur pour voir le résultat.

En fait, l’instruction va vous afficher la somme à chaque tour de la boucle.

Somme: 1  // sum=0+1=1 (i=1)
Somme: 3  // sum=1+2=2 (i=1+1=2) 
Somme: 6  // sum=3+3=6 (i=2+1=3)

La boucle while de Java

La boucle while en Java prend une expression/condition et répète le bloc de code de la boucle tant que la condition est remplie. En Java, la boucle while est souvent utilisée lorsque le nombre d’itérations n’est pas spécifié ou n’est pas connu.

while ( condition ) {  
  // le bloc de la boucle
  // incrémentation ou décrémentation
}

• La condition ou l’expression à vérifier se trouve au début.
• Si la condition de test est vraie, le code sera exécuté.
• Si la condition de test est fausse, la boucle va s’arrêter.
• Si la condition/expression spécifiée est fausse dans la première boucle, le code associé à cette condition ne sera pas exécuté.
• La valeur de la variable doit être incrémentée ou décrémentée à l’intérieur de la boucle, sinon le code associé à la boucle sera exécuté à l’infini.

Nous allons afficher la valeur de la variable num à la puissance 3 à chaque itération. Voyons donc comment nous pourrons mettre cela en œuvre.

public class Test {
    public static void main(String[] args) {
    	int num = 1;
        while (num <= 5) {          
          System.out.println(num + " à la puissance 3: " + num * num * num);
          num++;
        }          
    }
}

La valeur initiale de num est 1. La boucle while, s’exécute tant que la valeur de num est inférieure ou égale à 5.

1 à la puissance 3: 1
2 à la puissance 3: 8
3 à la puissance 3: 27
4 à la puissance 3: 64
5 à la puissance 3: 125

Prenons un autre exemple. Nous utiliserons les entrées/sorties et les conditions.

Exécutez ce code.

import java.util.*;

class Test {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int choix = 1;
        while (choix == 1) {
            int a;  // La variable que l'utilisateur va saisir

            System.out.println("Saisissez un nombre : ");
            a = s.nextInt();

            if (a % 2 == 0) {
                System.out.println("Votre nombre est pair.");
            } else {
                System.out.println("Votre nombre est impair.");
            }

            System.out.println("Saisissez 1 pour continuer ou 0 pour arrêter.");

            choix = s.nextInt();
        }

        System.out.println("Merci!");
    }
}

La boucle s’exécutera jusqu’à ce que la valeur de la variable choix sera différente de 1.

import java.util.* : l’étoile veut dire que nous importons tout ce qu’il y a dans java.util dans notre programme.

La boucle Java do-while

La boucle do-while est essentiellement identique à la boucle while ; la seule différence est que la boucle do-while s’exécute au moins une fois, quelle que soit la condition spécifiée. Puisque la condition est à la fin.

do { 
  // bloc de code de la boucle 
  // incrémentation / décrémentation
} while ( condition ) ; 

Prenons un exemple.

class Test {

    public static void main(String[] args) {
    	int num = 10;
        do {
          System.out.println(num + " à la puissance 3 : " + num * num * num);
          num++;
        } while (num <= 5); 
    }
}

Exécution du code :

10 à la puissance 3 : 1000

Comme vous pouvez le constater, la boucle a été exécutée malgré que la condition n’est pas remplie.

La boucle imbriquée en Java

Une boucle imbriquée est une boucle qui s’exécute à l’intérieur d’une autre boucle, donc la boucle interne sera le bloc de code de la boucle externe.

Supposons que nous voulons créer un programme qui affichera les joueurs de 3 équipes.

La boucle interne et la boucle externe sont initialisées à 1. La condition de la boucle externe est i<=3 (3 équipes). Alors que pour la boucle interne j<=4 (dans chaque équipe nous avons 4 joueurs). Ici, la boucle externe (des équipes) itère 3 fois et pour chaque itération de la boucle externe, la boucle interne (des joueurs) s’exécutera 4 fois.

class Test {
    public static void main(String[] args) {
        for (int i = 1; i <= 3; i++) {
	    for (int j = 1; j <= 4; j++) {
	        System.out.println("i=" + i + " et" + " j=" + j);
	    }
	    System.out.println("************************");
        }
    }
}

Exécution du code.

i=1 et j=1
i=1 et j=2
i=1 et j=3
i=1 et j=4
************************
i=2 et j=1
i=2 et j=2
i=2 et j=3
i=2 et j=4
************************
i=3 et j=1
i=3 et j=2
i=3 et j=3
i=3 et j=4
************************

Maintenant, nous allons utiliser la boucle imbriquée pour créer une table de multiplication.

class Test {

	public static void main(String[] args) {
        for (int i = 3; i <= 5; i++) {
            System.out.println("Table de multiplication de " + i);
            for (int j = 1; j <= 10; j++) {
                System.out.println(i + "*" + j + "=" + (i * j));
            }
        }
    }
}

Dans la première itération de la boucle externe for , la valeur de i est 3. Dans son bloc, « Table de multiplication de i » est affichée et la boucle for interne est exécutée.

Dans la première itération de la boucle interne, la valeur de i est 3 et celle de j est 1, donc dans son bloc, 3*1=3 est affichée.

Dans la deuxième itération de la boucle interne, la valeur de i est 3 et celle de j est 2, donc dans son bloc, 3*2=6 est affichée.

Puis, jusqu’à la dixième itération de la boucle interne dans laquelle 3*10=30 est affichée.

Ce qui met fin à la première itération de la boucle externe.

Dans les deuxième et troisième itérations de la boucle externe, le même processus est répété avec i égal à 4 et 5 respectivement.

Bref, il n’y a rien de nouveau dans l’imbrication des boucles. La boucle interne est comme toutes les autres instructions dans le bloc de la boucle externe.

Toutefois, notez que les valeurs de i ou la boucle externe représente des lignes et les valeurs de j qui est la boucle interne représente des colonnes.

Prenons un autre exemple classique, qui va afficher à chaque tour de boucle des étoiles dont le nombre sera celui de la colonne.

class Test {

	public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {            
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

Exécution du code.

*
**
***
****
*****

La boucle infinie en Java

Une boucle infinie est une boucle dont la condition est toujours vraie. En conséquence, elle continue d’exécuter son code pour toujours.

Exécutez l’exemple suivant. Pour arrêter la boucle tapez ctrl + c. Sinon, en bas dans la console, cliquez sur le rectangle rouge.

class Test {

	public static void main(String[] args) {
        for (int i = 2; i > 0; i++) {
            System.out.println(i);
        }
    }

Voici un autre exemple.

class Test {

    public static void main(String[] args) {
        for (int i = 12; true; i++) {
            System.out.println(i);
        }
    }
}

Puisque la condition de la boucle est vraie, elle continuera à s’exécuter.

Nous pouvons également créer une boucle infinie en laissant son expression conditionnelle vide. Lorsque l’expression conditionnelle est vide, elle est supposée vraie. Voyons un autre exemple.

class Test {

    public static void main(String[] args) {
        for (int i = 12;; i++) {
            System.out.println("Une boucle infinie");
        }
    }
}

L’instruction break

L’instruction Java break est utilisée pour rompre ou terminer la boucle selon une condition spécifiée. Dans une boucle interne, il arrête uniquement la boucle interne.

class Test {

    public static void main(String[] args) {
        for (int n = 1; n <= 5; n++) {
            System.out.println(n);
            if (n == 2) {
                break;
            }
        }
    }
}

Exécution du code.

1
2

Dans la première itération de la boucle , « 1 » est affiché et la condition n == 2 de if est vérifiée. Puisque la valeur de n est 1, la condition devient fausse.

Dans la deuxième itération de la boucle , ‘2’ est à affiché et la condition de if est vérifiée. Cette fois, la valeur de n est 2 et donc la condition de if devient vraie. Dans le code de if , l’instruction break termine la boucle.

Voici le même code avec la boucle while.

class Test {
    public static void main(String[] args) {
        int n = 1;

        while (n <= 5) {
            System.out.println("*");
            if (n == 2) {
                break;
            }
            n++;
        }
    }
}

Prenons un exemple d’une boucle infinie.

import java.util.Scanner;

class Test {

    public static void main(String[] args) {
        int x;
        Scanner s = new Scanner(System.in);

        for (;;) {
            System.out.println("Enter 0 to stop");
            x = s.nextInt();
            if (x == 0) {
                break;
            }
        }
    }
}

C’est une boucle infinie, afin de la terminer, nous utilisons l’instruction break. Si l’utilisateur entre 0, la condition de if sera satisfaite et l’instruction break terminera la boucle.

L’instruction continue

L’instruction Java continue est utilisée pour ignorer le bloc de code de la boucle en fonction de la condition. Donc, si la condition de l’instruction continue est TRUE, elle ignorera l’exécution du bloc de code de la boucle et retournera au début de la boucle, mais si la condition est FALSE, elle continuera à parcourir le reste du code de la boucle.

Donc, l’instruction continue ignore les instructions restantes dans la boucle et commence l’itération suivante.

class Test {

    public static void main(String[] args) {
        for (int n = 1; n <= 10; n++) {
            if (n == 5) {
                continue;
            }
            System.out.println(n);
        }
    }
}

Lorsque vous exécutez ce, vous allez remarquer que le 5 n’est pas affiché. En effet, à la cinquième itération, lorsque la valeur de n deviendra 5, la condition de if sera vraie et l’instruction continue dans le bloc de code de if sera exécutée. Ainsi, l’instruction suivante System.out.println(n) ne sera pas exécutée et la sixième itération commencera.

Vous aurez le même résultat avec une boucle while.

class Test {

    public static void main(String[] args) {
        int n = 1;

        while (n <= 10) {
            if (n == 5) {
                n++;
                continue;
            }
            System.out.println(n);
            n++;
        }
    }
}