Instruction continue en Java – Maîtriser le contrôle de boucle avec exemples

Instruction continue en Java

Ce tutoriel explique les instructions continue et continue étiqueté en Java, avec des exemples clairs pour vous aider à contrôler le flux des boucles efficacement.

En travaillant avec des boucles, vous pourriez parfois vouloir ignorer certaines instructions ou terminer la boucle prématurément. Dans de tels cas, les instructions break et continue sont les outils que vous utiliserez.

Pour apprendre l'instruction break, visitez Java break. Ici, nous nous concentrerons sur l'instruction continue.

---

Java continue

L'instruction continue ignore l'itération courante d'une boucle (for, while, do…while, etc.). Après l'instruction continue, le programme saute à la vérification de terminaison de la boucle (et, pour les boucles for, l'expression de mise à jour).

Voici la syntaxe :

continue;

Note : L'instruction continue est le plus souvent utilisée à l'intérieur de blocs conditionnels (par ex. instructions if).

---

Fonctionnement de l'instruction continue Java

---

Exemple 1 : Instruction continue Java

class Main {
    public static void main(String[] args) {
        // boucle for
        for (int i = 1; i <= 10; ++i) {
            // si la valeur de i est entre 4 et 9
            // continue est exécuté
            if (i > 4 && i < 9) {
                continue;
            }
            System.out.println(i);
        }
    }
}

Sortie :

1
2
3
4
9
10

Dans ce programme, une boucle for affiche la valeur de i pour chaque itération. L'instruction continue s'active quand i est supérieur à 4 et inférieur à 9, causant l'ignorance de l'instruction println pour 5, 6, 7 et 8.

---

Exemple 2 : Calculer la somme de 5 nombres positifs

import java.util.Scanner;
class Main {
    public static void main(String[] args) {
        Double number, sum = 0.0;
        // créer un objet Scanner
        Scanner input = new Scanner(System.in);
        for (int i = 1; i < 6; ++i) {
            System.out.print("Enter number " + i + " : ");
            // prend l'entrée de l'utilisateur
            number = input.nextDouble();
            // si le nombre est négatif ou zéro
            // l'instruction continue est exécutée
            if (number <= 0.0) {
                continue;
            }
            sum += number;
        }
        System.out.println("Sum = " + sum);
        input.close();
    }
}

Sortie :

Enter number 1: 2.2
Enter number 2: 5.6
Enter number 3: 0
Enter number 4: -2.4
Enter number 5: -3
Sum = 7.8

Ici, l'instruction continue ignore toute entrée négative ou nulle, assurant que seules les valeurs positives contribuent au total.

Note : Nous avons utilisé la classe Scanner pour lire l'entrée utilisateur. Pour en savoir plus, visitez Java Scanner.

---

Java continue avec boucle imbriquée

Quand les boucles sont imbriquées, un continue à l'intérieur de la boucle interne n'affecte que l'itération courante de cette boucle interne.

---

Exemple 3 : continue avec boucle imbriquée

class Main {
    public static void main(String[] args) {
        int i = 1, j = 1;
        // boucle externe
        while (i <= 3) {
            System.out.println("Outer Loop: " + i);
            // boucle interne
            while(j <= 3) {
                if(j == 2) {
                    j++;
                    continue;
                }
                System.out.println("Inner Loop: " + j);
                j++;
            }
            i++;
        }
    }
}

Sortie

Outer Loop: 1
Inner Loop: 1
Inner Loop: 3
Outer Loop: 2
Outer Loop: 3

Dans cet exemple, le continue à l'intérieur de la boucle interne ignore l'itération quand j égale 2, empêchant l'affichage de « Inner Loop: 2 ».

---

Instruction continue étiquetée

En plus du continue de base, Java prend aussi en charge une version étiquetée qui dirige le flux vers une boucle spécifique. La syntaxe est :

continue label;

Cela fait que le programme ignore l'itération courante de la boucle identifiée par label.

Dans l'illustration ci-dessus, l'étiquette cible la boucle externe, démontrant comment le continue peut ignorer une itération entière de cette boucle.

---

Exemple 4 : instruction continue étiquetée

class Main {
    public static void main(String[] args) {
        // boucle externe étiquetée first
        first: for (int i = 1; i < 6; ++i) {
            // boucle interne
            for (int j = 1; j < 5; ++j) {
                if (i == 3 || j == 2)
                    // ignore l'itération courante de la boucle externe
                    continue first;
                System.out.println("i = " + i + "; j = " + j);
            }
        }
    }
}

Sortie :

i = 1; j = 1
i = 2; j = 1
i = 4; j = 1
i = 5; j = 1

Ici, le continue étiqueté saute à l'itération suivante de la boucle nommée first chaque fois que i égale 3 ou j égale 2.

Note : Le continue étiqueté peut être puissant mais réduit souvent la lisibilité. Quand vous rencontrez un tel besoin, envisagez de refactoriser pour garder le flux clair.