mot-clé break en Java

Le mot-clé break en Java est utilisé pour mettre fin prématurément à l'exécution d'une boucle ou d'une instruction de commutation. Lorsqu'une instruction break est rencontrée, le contrôle est transféré à l'instruction qui suit immédiatement la boucle ou le commutateur qui l'entoure.

Utilisation

La déclaration break est couramment utilisée dans les scénarios suivants :

• Pour quitter une boucle (par exemple, for, while, do-while) avant qu'elle n'ait parcouru tous les éléments.
• Pour mettre fin à une instruction switch une fois qu'un cas correspondant a été exécuté.

Syntax

break;

Exemples

Exemple 1 : L'utilisation break dans un for Boucle

public class BreakInForLoop {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break; // Terminate loop when i is 5
            }
            System.out.println("i: " + i);
        }
    }
}

Dans cet exemple, la boucle for itère de 0 à 9. Cependant, lorsque i est égal à 5, l'instruction break est exécutée, ce qui met fin prématurément à la boucle.

Exemple 2 : L'utilisation break dans un while Boucle

public class BreakInWhileLoop {
    public static void main(String[] args) {
        int i = 0;
        while (i < 10) {
            if (i == 5) {
                break; // Terminate loop when i is 5
            }
            System.out.println("i: " + i);
            i++;
        }
    }
}

Ici, la boucle while continue tant que i est inférieur à 10. Lorsque i atteint 5, l'instruction break met fin à la boucle.

Exemple 3 : L'utilisation break dans un switch Déclaration

public class BreakInSwitch {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break; // Terminate switch after matching case
            case 4:
                System.out.println("Thursday");
                break;
            default:
                System.out.println("Invalid day");
        }
    }
}

Dans cet exemple, l'instruction switch vérifie la valeur de day. Lorsque day est égal à 3, "Wednesday" est imprimé et l'instruction break met fin à l'instruction switch, empêchant l'exécution des cas suivants.

Exemple 4 : L'utilisation break dans un do-while Boucle

public class BreakInDoWhileLoop {
    public static void main(String[] args) {
        int i = 0;
        do {
            if (i == 5) {
                break; // Terminate loop when i is 5
            }
            System.out.println("i: " + i);
            i++;
        } while (i < 10);
    }
}

Dans cette boucle do-while, la boucle se poursuit tant que i est inférieur à 10. Lorsque i est égal à 5, l'instruction break met fin prématurément à la boucle.

Conseils et bonnes pratiques

• Utilisez-le avec discernement: Si break peut rendre les boucles et les instructions de commutation plus efficaces, une utilisation excessive peut rendre le code plus difficile à lire et à maintenir.
• Boucles imbriquées: Dans les boucles imbriquées, l'instruction break ne met fin qu'à la boucle la plus interne. Utilisez les instructions break étiquetées si vous devez quitter plusieurs niveaux de boucles imbriquées.

  outerLoop:
  for (int i = 0; i < 5; i++) {
      for (int j = 0; j < 5; j++) {
          if (i == 2 && j == 2) {
              break outerLoop; // Terminates both loops
          }
          System.out.println("i: " + i + ", j: " + j);
      }
  }

• Évitez le code spaghetti: L'utilisation excessive des instructions break peut conduire à un code difficile à suivre. Visez toujours un code clair et facile à maintenir.
• Boîtiers de commutation: Utilisez toujours break dans chaque cas d'une déclaration switch, à moins que vous ne souhaitiez délibérément passer au cas suivant.