Branching en Java (et label de boucle)

Dans ce guide complet sur le branching en Java, nous abordons les différentes structures de contrôle de flux qui permettent de modifier le chemin d’exécution d’un programme. Ce document pédagogique, optimisé pour le SEO et intégrant le terme branching en Java ainsi que ses synonymes, vous explique comment utiliser efficacement les boucles imbriquées, les instructions break, continue et return dans vos programmes.

Contrôle de Flux avec Branching en Java

Jusqu’à présent, nous avons travaillé avec des boucles simples qui se terminent dès que leur expression booléenne est fausse. Ici, nous vous présentons d’autres façons pour qu’une boucle se termine ou bifurque. En outre, vous découvrirez que le chemin d’exécution à l’exécution peut être bien plus complexe que dans les exemples précédents.

Boucles Imbriquées et Branching

Une boucle imbriquée est une boucle qui contient une autre boucle (while, do/while, for ou for-each). Par exemple, considérez le code suivant qui itère sur un tableau à deux dimensions, c’est-à-dire un tableau contenant d’autres tableaux.

// Déclaration d'un tableau à deux dimensions
int[][] monTableauComplexe = {{5,2,1,3}, {3,9,8,9}, {5,7,12,7}};

for (int[] monTableauSimple : monTableauComplexe) {
    for (int i = 0; i < monTableauSimple.length; i++) {
        System.out.print(monTableauSimple[i] + "\t");
    }
    System.out.println();
}

De plus, considérez cet exemple qui utilise une boucle while avec une boucle do/while imbriquée :

int hippopotameAffame = 8;
while (hippopotameAffame > 0) {
    do {
        hippopotameAffame -= 2;
    } while (hippopotameAffame > 5);
    hippopotameAffame--;
    System.out.print(hippopotameAffame + ", ");
}

Utilisation d’Étiquettes Optionnelles

Les étiquettes optionnelles permettent d’indiquer un point précis dans le code vers lequel le flux d’exécution peut être redirigé. Par exemple, dans le code suivant, nous avons ajouté des étiquettes pour identifier les boucles externes et internes.

int[][] monTableauComplexe = {{5,2,1,3}, {3,9,8,9}, {5,7,12,7}};

BOUCLE_EXTERIEURE: for (int[] monTableauSimple : monTableauComplexe) {
    BOUCLE_INTERIEURE: for (int i = 0; i < monTableauSimple.length; i++) {
        System.out.print(monTableauSimple[i] + "\t");
    }
    System.out.println();
}

Par ailleurs, voici un exemple qui montre comment ajouter des étiquettes à une instruction if :

int grenouille = 15;

MAUVAIS_IDEE: if (grenouille > 10)
    ENCORE_MAUVAIS_IDEE: {
        grenouille++;
    }

Instruction `break` et Contrôle de Boucle

L’instruction break permet de sortir prématurément d’une boucle. Dans l’exemple suivant, nous recherchons la première occurrence d’une valeur dans un tableau à deux dimensions.

public class TrouverDansMatrice {
    public static void main(String[] args) {
        int[][] liste = {{1,13}, {5,2}, {2,2}};
        int valeurRecherchee = 2;
        int positionX = -1;
        int positionY = -1;

        BOUCLE_PARENT: for (int i = 0; i < liste.length; i++) {
            for (int j = 0; j < liste[i].length; j++) {
                if (liste[i][j] == valeurRecherchee) {
                    positionX = i;
                    positionY = j;
                    break BOUCLE_PARENT;
                }
            }
        }
        if (positionX == -1 || positionY == -1) {
            System.out.println("Valeur " + valeurRecherchee + " non trouvée");
        } else {
            System.out.println("Valeur " + valeurRecherchee + " trouvée à: (" + positionX + "," + positionY + ")");
        }
    }
}

Notez que si l’instruction break est utilisée sans étiquette, seule la boucle interne se termine. Si le break est complètement omis, la boucle parcourt l’intégralité de la structure, recherchant ainsi la dernière occurrence de la valeur.

Instruction `continue` pour Passer à l’Itération Suivante

L’instruction continue termine l’itération courante de la boucle et passe directement à la vérification de la condition. Voici un exemple illustrant comment un gardien de zoo doit nettoyer le premier léopard de chaque étable tout en sautant l’étable « b ».

public class PlanningDeNettoyage {
    public static void main(String[] args) {
        NETTOYAGE: for (char etables = 'a'; etables <= 'd'; etables++) {
            for (int leopard = 1; leopard < 4; leopard++) {
                if (etables == 'b' || leopard == 2) {
                    continue NETTOYAGE;
                }
                System.out.println("Nettoyage : " + etables + "," + leopard);
            }
        }
    }
}

En outre, si l’étiquette est omise dans l’instruction continue, le contrôle revient à la boucle interne, ce qui entraîne un comportement différent dans l’affichage des résultats.

Utilisation de l’Instruction `return` pour Simplifier le Contrôle

L’instruction return permet de quitter une méthode et, dans certains cas, de simplifier la gestion des boucles imbriquées. Le code suivant réécrit la classe précédente en utilisant return pour interrompre la recherche dès que la valeur est trouvée.

public class TrouverDansMatriceAvecRetour {
    private static int[] rechercherValeur(int[][] liste, int valeur) {
        for (int i = 0; i < liste.length; i++) {
            for (int j = 0; j < liste[i].length; j++) {
                if (liste[i][j] == valeur) {
                    return new int[] { i, j };
                }
            }
        }
        return null;
    }

    public static void main(String[] args) {
        int[][] liste = { { 1, 13 }, { 5, 2 }, { 2, 2 } };
        int valeurRecherchee = 2;
        int[] resultats = rechercherValeur(liste, valeurRecherchee);

        if (resultats == null) {
            System.out.println("Valeur " + valeurRecherchee + " non trouvée");
        } else {
            System.out.println("Valeur " + valeurRecherchee + " trouvée à: (" + resultats[0] + "," + resultats[1] + ")");
        }
    }
}

Code Illustratif : Détection de Code Inaccessible

Il est important de noter que toute instruction placée immédiatement après un break, continue ou return dans le même bloc est considérée comme inatteignable et ne compilera pas.

// Exemple de code inatteignable
int controleDate = 0;
while (controleDate < 10) {
    controleDate++;
    if (controleDate > 100) {
        break;
        controleDate++; // NE COMPILE PAS
    }
}

int minute = 1;
SURVEILLANCE: while (minute > 2) {
    if (minute++ > 2) {
        continue SURVEILLANCE;
        System.out.print(minute); // NE COMPILE PAS
    }
}

int heure = 2;
switch (heure) {
    case 1:
        return;
        heure++; // NE COMPILE PAS
    case 2:
}

Tableau Récapitulatif des Instructions de Contrôle

Le tableau ci-dessous résume l’utilisation des étiquettes, break, continue et yield dans différentes structures de contrôle en Java.

Structure	Supporte les étiquettes	Supporte break	Supporte continue	Supporte yield
while	Oui	Oui	Oui	Non
do/while	Oui	Oui	Oui	Non
for	Oui	Oui	Oui	Non
switch	Oui	Oui	Non	Oui

En conclusion, la compréhension et la maîtrise du branching en Java vous permettront d’écrire des programmes plus flexibles et efficaces. De plus, l’utilisation judicieuse de boucles imbriquées et d’instructions de contrôle améliore la lisibilité et la maintenabilité de votre code.

Transitionnellement, n’hésitez pas à expérimenter ces concepts dans vos projets personnels pour renforcer votre compréhension du contrôle de flux en Java.

Branching en Java