Sortir des boucles imbriquées

1. Vue d'ensemble

Dans ce didacticiel, nous allons créer des exemples pour montrer différentes façons d'utiliser la rupture dans une boucle. Ensuite, nous verrons également comment terminer une boucle sans utiliser du tout break .

2. Le problème

Les boucles imbriquées sont très utiles, par exemple, pour rechercher dans une liste de listes.

Un exemple serait une liste d'étudiants, où chaque étudiant a une liste de cours prévus. Disons que nous voulons trouver le nom d'une personne qui a planifié le cours 0 .

Tout d'abord, nous bouclerions la liste des étudiants. Ensuite, à l'intérieur de cette boucle, nous ferions une boucle sur la liste des cours prévus.

Lorsque nous imprimons les noms des étudiants et des cours, nous obtenons le résultat suivant:

student 0 course 0 course 1 student 1 course 0 course 1

Nous voulions trouver le premier étudiant qui planifiait le cours 0 . Cependant, si nous n'utilisons que des boucles, l'application continuera à rechercher une fois le cours trouvé.

Une fois que nous avons trouvé une personne qui a planifié le cours spécifique, nous voulons arrêter la recherche. Continuer la recherche prendrait plus de temps et de ressources sans que nous ayons besoin d'informations supplémentaires. C'est pourquoi nous voulons sortir de la boucle imbriquée.

3. Pause

La première option dont nous disposons pour sortir d'une boucle imbriquée est d'utiliser simplement l' instruction break :

String result = ""; for (int outerCounter = 0; outerCounter < 2; outerCounter++) { result += "outer" + outerCounter; for (int innerCounter = 0; innerCounter < 2; innerCounter++) { result += "inner" + innerCounter; if (innerCounter == 0) { break; } } } return result;

Nous avons une boucle externe et une boucle interne, les deux boucles ont deux itérations. Si le compteur de la boucle interne est égal à 0, nous exécutons la commande break . Lorsque nous exécutons l'exemple, il affichera le résultat suivant:

outer0inner0outer1inner0

Ou nous pourrions ajuster le code pour le rendre un peu plus lisible:

outer 0 inner 0 outer 1 inner 0

Est-ce que c'est ca ce que nous voulons?

Presque, la boucle interne est terminée par l'instruction break une fois que 0 est trouvé. Cependant, la boucle extérieure continue, ce qui n'est pas ce que nous voulons. Nous voulons arrêter complètement le traitement dès que nous avons la réponse.

4. Pause étiquetée

L'exemple précédent était un pas dans la bonne direction, mais nous devons l'améliorer un peu. Nous pouvons le faire en utilisant une pause étiquetée :

String result = ""; myBreakLabel: for (int outerCounter = 0; outerCounter < 2; outerCounter++) { result += "outer" + outerCounter; for (int innerCounter = 0; innerCounter < 2; innerCounter++) { result += "inner" + innerCounter; if (innerCounter == 0) { break myBreakLabel; } } } return result;

Une rupture étiquetée terminera la boucle externe au lieu de simplement la boucle interne. Nous y parvenons en ajoutant myBreakLabel en dehors de la boucle et en modifiant l'instruction break pour arrêter myBreakLabel . Après avoir exécuté l'exemple, nous obtenons le résultat suivant:

outer0inner0

Nous pouvons le lire un peu mieux avec un peu de mise en forme:

outer 0 inner 0

Si nous regardons le résultat, nous pouvons voir que la boucle interne et la boucle externe sont terminées, ce que nous voulions réaliser.

5. Retour

Comme alternative, nous pourrions également utiliser l' instruction return pour renvoyer directement le résultat lorsqu'il est trouvé:

String result = ""; for (int outerCounter = 0; outerCounter < 2; outerCounter++) { result += "outer" + outerCounter; for (int innerCounter = 0; innerCounter < 2; innerCounter++) { result += "inner" + innerCounter; if (innerCounter == 0) { return result; } } } return "failed";

L'étiquette est supprimée et l' instruction break est remplacée par une instruction return .

Lorsque nous exécutons le code ci-dessus, nous obtenons le même résultat que pour la rupture étiquetée. Notez que pour que cette stratégie fonctionne, nous devons généralement déplacer le bloc de boucles dans sa propre méthode.

6. Conclusion

Donc, nous avons juste regardé ce qu'il faut faire lorsque nous devons sortir tôt d'une boucle, comme lorsque nous avons trouvé l'élément que nous recherchons. La pause mot - clé est utile pour les boucles simples, et nous pouvons utiliser étiquetés pause s pour les boucles imbriquées.

Alternativement, nous pouvons utiliser une instruction return . L'utilisation de return rend le code plus lisible et moins sujet aux erreurs car nous n'avons pas à penser à la différence entre les sauts non étiquetés et étiquetés.

N'hésitez pas à consulter le code sur GitHub.