Est-ce une mauvaise pratique d’utiliser break pour sortir d’une boucle en Java?

Question

Je me demandais si c'était une "mauvaise pratique" d'utiliser une instruction break pour sortir d'une boucle au lieu de remplir la condition de boucle?

Je ne connais pas suffisamment Java ni la machine virtuelle Java pour savoir comment une boucle est gérée. Je me demandais donc si je ne faisais pas abstraction de quelque chose de critique.

L'objet principal de cette question: existe-t-il des frais généraux de préformance spécifiques?

Answer 1

Bon dieu pas. Parfois, il ya une possibilité que quelque chose peut se produire dans la boucle qui satisfait à l'exigence globale, sans la satisfaction de la logique condition de boucle. Dans ce cas, break est utilisé, de vous arrêter à vélo autour d'une boucle inutilement.

Exemple

String item;

for(int x = 0; x < 10; x++)
{
    // Linear search.
    if(array[x].equals("Item I am looking for"))
    {
       //you've found the item. Let's stop.
       item = array[x];
       break; 
    }
}

Quoi de plus logique dans cet exemple. Continuer la boucle de 10 à chaque fois, même après que vous l'avez trouvé, ou en boucle jusqu'à ce que vous trouver le point et arrêter? Ou pour le dire dans le monde réel des termes, lorsque vous trouver vos clés, gardez-vous à la recherche?

Edit en réponse au commentaire

Pourquoi ne pas mettre en x de 11 de briser la boucle? Il ne sert à rien. Nous avons break! À moins que votre code est faire l'hypothèse que l' x est nettement plus grande que 10 plus tard (et il ne devrait probablement pas être), alors vous êtes bien juste à l'aide de break.

Edit par souci d'exhaustivité

Il y a certainement d'autres façons de simuler break. Par exemple, l'ajout de la logique supplémentaire à votre résiliation condition dans la boucle. Dire que c'est soit la boucle inutilement ou de l'utilisation break n'est pas juste. Comme l'a souligné, une boucle while peut souvent obtenir une fonctionnalité similaire. Par exemple, à la suite de l'exemple ci-dessus..

while(x < 10 && item == null)
{
    if(array[x].equals("Item I am looking for"))
    {
        item = array[x];
    }

    x++;
}

À l'aide de break signifie simplement que vous pouvez obtenir cette fonctionnalité avec un for boucle. Cela signifie également que vous n'avez pas à continuer à ajouter des conditions dans votre cessation d'emploi à la logique, à chaque fois que vous voulez la boucle à se comporter différemment. Par exemple.

for(int x = 0; x < 10; x++)
{
   if(array[x].equals("Something that will make me want to cancel"))
   {
       break;
   }
   else if(array[x].equals("Something else that will make me want to cancel"))
   {
       break;
   }
   else if(array[x].equals("This is what I want"))
   {
       item = array[x];
   }
}

Plutôt qu'un while loop , avec un raccordement condition qui ressemble à ceci:

while(x < 10 && !array[x].equals("Something that will make me want to cancel") && 
                !array[x].equals("Something else that will make me want to cancel"))

Answer 2

À l'aide de break, tout comme dans pratiquement toute autre fonctionnalité du langage, peut être une mauvaise pratique, dans un contexte particulier, où vous êtes clairement en abuser. Mais certains très important idiomes ne peuvent être codés sans elle, ou, au moins, aurait pour résultat beaucoup moins lisible le code. Dans ces cas, break est le chemin à parcourir.

En d'autres termes, ne pas écouter toute la couverture, non qualifiés des conseils à propos de break ou quoi que ce soit d'autre. Ce n'est pas une fois que j'ai vu du code totalement décharné juste pour littéralement faire respecter une "bonne pratique".

Au sujet de votre préoccupation à propos de la surcharge de performance, il n'y a absolument aucun. Au niveau du compilateur; il n'y a pas explicite des constructions en boucle toute façon: tous les flux de contrôle est mis en œuvre en termes de mise en sauts.

Answer 3

Le JLS spécifie une pause est un arrêt anormal d'une boucle. Cependant, juste parce que c'est considéré comme anormal ne signifie pas qu'il n'est pas utilisé dans de nombreux exemples de code, des projets, des produits, des navettes spatiales, etc. La spécification de la JVM ne fait pas état de l'existence ou de l'absence de perte de performance, mais il est clair exécution de code continuera après la boucle.

Cependant, la lisibilité du code, peut souffrir d'étranges pauses. Si vous êtes collant une pause dans un complexe si l'instruction entouré par des effets secondaires et de l'impair de nettoyage de code, avec, éventuellement, un multi-niveaux de rompre avec une étiquette(ou pire, avec un étrange jeu de conditions de sortie de l'un après l'autre), il ne va pas être facile à lire pour tout le monde.

Si vous souhaitez rompre votre boucle en forçant la variable d'itération à l'extérieur de l'itération de la gamme, ou par ailleurs l'introduction d'un pas-forcément-de manière directe de la sortie, c'est moins lisible qu' break.

Cependant, le bouclage fois supplémentaires dans le vide d'une manière qui est presque toujours une mauvaise pratique car il faut plus d'itérations et peut-être pas clair.

Answer 4

Non, il n'est pas une mauvaise pratique pour sortir de la boucle lorsque si certaines condition souhaitée est atteinte(comme une correspondance est trouvée). De nombreuses fois, vous pouvez arrêter les itérations parce que vous avez déjà obtenu ce que vous voulez, et il n'y a pas de point d'itération supplémentaire. Mais, assurez-vous que vous n'êtes pas accidentellement manque quelque chose ou de casser lorsqu'il n'est pas nécessaire.

Cela peut également ajouter à l'amélioration de la performance si vous cassez la boucle, au lieu de parcourir des milliers de documents, même si le but de la boucle est complète(c'est à dire peut-être pour correspondre enregistrement requis est déjà fait).

Exemple :

for (int j = 0; j < type.size(); j++) {
        if (condition) {
            // do stuff after which you want 

            break; // stop further iteration
        }

}

Answer 5

L'utilisation de boucles de rodage peut être parfaitement légitime et même constituer le seul moyen de résoudre certains problèmes.

Cependant, sa mauvaise réputation tient au fait que les nouveaux programmeurs en abusent généralement, ce qui crée une confusion dans le code, notamment en utilisant break pour arrêter la boucle dans des conditions qui auraient pu être écrites dans l’instruction de condition de boucle.