Différence entre break et continue déclaration
est-ce que quelqu'un peut me dire la différence entre break et continue ?
21 réponses
break sort d'une boucle, continue saute à la prochaine itération.
Voir les Instructions de branchement pour plus de détails et des exemples de code:
break
l'instruction break a deux formes: étiqueté et non étiqueté. Vous avez vu l' forme non marquée dans la discussion précédente de l'énoncé de l'interrupteur. Vous peut également utiliser un break non étiqueté pour terminer un for, while, Ou do-while boucle.[ ..]
une rupture sans étiquette l'instruction termine l'interrupteur le plus à l'intérieur, pour, tout, ou-lors de la déclaration, mais une étiquette pause met fin à l'extérieur déclaration.
continue
l'énoncé continue saute l'itération actuelle de A for, alors que , ou-lors de la boucle. La forme non marquée saute à l'extrémité de l'intérieur boucle du corps et évalue l'expression booléenne qui contrôle la boucle. [...]
a étiqueté l'instruction continue omet l'itération actuelle d'une boucle extérieure marquée avec l'étiquette donnée.
System.out.println ("starting loop:");
for (int n = 0; n < 7; ++n)
{
System.out.println ("in loop: " + n);
if (n == 2) {
continue;
}
System.out.println (" survived first guard");
if (n == 4) {
break;
}
System.out.println (" survived second guard");
// continue at head of loop
}
// break out of loop
System.out.println ("end of loop or exit via break");
il en résultera la sortie suivante:
starting loop:
in loop: 0
survived first guard
survived second guard
in loop: 1
survived first guard
survived second guard
in loop: 2
in loop: 3
survived first guard
survived second guard
in loop: 4
survived first guard
end of loop or exit via break
vous pouvez étiqueter un bloc, pas seulement un pour-boucle, et puis casser/continuer d'un bloc imbriqué à un extérieur. Dans quelques cas cela pourrait être utile, mais en général vous essayerez d'éviter un tel code, sauf que la logique du programme est beaucoup mieux à comprendre que dans l'exemple suivant:
first:
for (int i = 0; i < 4; ++i)
{
second:
for (int j = 0; j < 4; ++j)
{
third:
for (int k = 0; k < 4; ++k)
{
System.out.println ("inner start: i+j+k " + (i + j + k));
if (i + j + k == 5)
continue third;
if (i + j + k == 7)
continue second;
if (i + j + k == 8)
break second;
if (i + j + k == 9)
break first;
System.out.println ("inner stop: i+j+k " + (i + j + k));
}
}
}
parce que c'est possible, ça ne veut pas dire que vous devez l'utiliser.
si vous voulez obscurcir votre code d'une manière amusante, vous ne choisissez pas un nom méchant, mais http: et suivez-le avec un commentaire, qui semble étranger, comme une Webadresse dans le code source:
http://stackoverflow.com/questions/462373
for (int i = 0; i < 4; ++i)
{
if (i == 2)
break http;
je suppose que ça vient d'un quizzle de Joshua Bloch. :)
Break quitte complètement la boucle et exécute les instructions après la boucle. Alors que Continue quitte l'itération courante et exécute avec la valeur suivante dans la boucle.
Ce Code Explique Tout:
public static void main(String[] args) {
for(int i=0;i<10;i++)
{
if (i==4)
{
break;
}
System.out.print(i+"\t");
}
System.out.println();
for(int i=0;i<10;i++)
{
if (i==4)
{
continue;
}
System.out.print(i+"\t");
}
}
sortie:
0 1 2 3
0 1 2 3 5 6 7 8 9
break sort complètement de la boucle. continue saute les déclarations après la continue déclaration et continue la boucle.
excellente réponse simple et précis.
j'ajouterais un exemple de code.
C:\oreyes\samples\java\breakcontinue>type BreakContinue.java
class BreakContinue {
public static void main( String [] args ) {
for( int i = 0 ; i < 10 ; i++ ) {
if( i % 2 == 0) { // if pair, will jump
continue; // don't go to "System.out.print" below.
}
System.out.println("The number is " + i );
if( i == 7 ) {
break; // will end the execution, 8,9 wont be processed
}
}
}
}
C:\oreyes\samples\java\breakcontinue>java BreakContinue
The number is 1
The number is 3
The number is 5
The number is 7
Un break résultats de l'instruction à la résiliation de la déclaration à laquelle il s'applique ( switch , for , do , ou while ).
A continue est utilisée pour mettre fin à l'itération de la boucle courante et pour retourner le contrôle à l'instruction de boucle.
continue saute le courant d'exécution boucle et se déplace vers la prochaine boucle tandis que break sort de la boucle et exécute l'énoncé suivant après the loop.
J'ai appris la différence en utilisant le code suivant. Découvrez les différentes sorties.Espérons que cette aide.
public static void main(String[] args) {
for(int i = 0; i < 5; i++){
if (i == 3) {
continue;
}
System.out.print(i);
}
}//prints out 0124, continue moves to the next iteration skipping printing 3
public static void main(String[] args) {
for(int i = 0; i < 5; i++){
if (i == 3) {
break;
}
System.out.print(i);
}
}//prints out 012, break moves out of the loop hence doesnt print 3 and 4
considérer ce qui suit:
int n;
for(n = 0; n < 10; ++n) {
break;
}
System.out.println(n);
break cause la fin de la boucle et la valeur de n est 0.
int n;
for(n = 0; n < 10; ++n) {
continue;
}
System.out.println(n);
continue fait revenir le compteur de programme à la première ligne de la boucle (la condition est vérifiée et la valeur de n est incrément) et la valeur finale de n est 10.
il devrait également à noter que break ne termine l'exécution de la boucle qu'elle se trouve à l'intérieur:
int m;
for(m = 0; m < 5; ++m)
{
int n;
for(n = 0; n < 5; ++n) {
break;
}
System.out.println(n);
}
System.out.println(m);
va produire quelque chose à l'effet de
0
0
0
0
0
5
Le break déclaration des pauses hors de la boucle (la prochaine instruction à exécuter est la première après l'accolade fermante), alors que continue commence la boucle à l'itération suivante.
Instruction " Break
il est parfois nécessaire de sortir d'une boucle avant que la boucle n'ait terminé son itération complète sur toutes les valeurs de pas. Par exemple, en boucle sur une liste de nombres jusqu'à ce que vous trouviez un nombre qui satisfait une certaine condition. Ou en boucle sur un flux de caractères à partir d'un fichier jusqu'à un certain caractère est lu.
Dans l'exemple suivant, nous utilisons un simple pour boucle pour imprimer des valeurs de 0 à 9:
for(int i=0; i<10; i++) {
System.out.println(i);
}
sortie:
0
1
2
3
4
5
6
7
8
9
maintenant si nous ajoutons une instruction break quand i==4, Notre code sortira de la boucle une fois que i égale 4. Vous pouvez utiliser l'instruction break pour sortir de boucles for, while et do-while. L'instruction break ne sortira que de la boucle courante. Pour sortir d'une boucle extérieure d'une boucle intérieure imbriquée, vous devez utiliser des étiquettes avec la coupure déclaration.
for(int i=0; i<10; i++) {
System.out.println(i);
if(i==4) {
break;
}
}
sortie:
0
1
2
3
4
Suite Déclaration
Java continue statement saute sur l'itération actuelle d'une boucle et passe directement à l'itération suivante. Après avoir appelé l'instruction continuer dans une boucle for, l'exécution de la boucle exécutera la valeur step et évaluera la condition booléenne avant de procéder avec la prochaine itération. Dans l'exemple suivant, Nous imprimons toutes les valeurs de 0 à 9 dans une boucle, mais nous sautons l'impression 4.
for(int i=0; i<10; i++) {
if(i==4) {
continue;
}
System.out.println(i);
}
sortie:
0
1
2
3
5 <---- SKIPPED OVER 4 and continued with next loop iteration
6
7
8
9
Boucle Étiquette D'Instruction " Break Vous pouvez utiliser les étiquettes dans les boucles imbriquées en spécifiant où vous voulez que l'exécution continue après l'éclatement d'une boucle interne. Normalement, l'instruction break ne sortira de la boucle la plus interne que lorsque vous voulez sortir d'une boucle externe, vous pouvez utiliser des étiquettes pour accomplir ceci, essentiellement en faisant quelque chose de similaire à une déclaration goto.
L'exemple suivant utilise 3 boucles, toutes imbriquées les unes dans les autres. Puisqu'il n'y a aucun moyen de sortir complètement de la boucle la plus externe à partir de l'intérieur de la boucle la plus interne, nous pouvons utiliser l'étiquette "outer1" pour accomplir ceci et spécifier l'étiquette à côté de la déclaration de rupture.
outer1:
for(int i=0; i<5; i++) {
for(int j=0; j<4; j++) {
for(int k=0; k<2; k++) {
System.out.println("[" + i + "][" + j + "][" + k + "]");
if(j == 3) {
break outer1;
}
}
}
}
sortie:
[0][0][0]
[0][0][1]
[0][1][0]
[0][1][1]
[0][2][0]
[0][2][1]
[0][3][0]
notez comment la dernière ligne affichée est " 0 [0]" c'est où j == 3 et c'est là que nous avons appelé "break outer1;" pour sortir de la boucle la plus externe.
Boucle Des Étiquettes De Poursuivre L'Instruction
vous pouvez également utiliser des étiquettes avec le mot-clé continue pour continuer à Boucler à partir d'un point spécifique. En prenant l'exemple précédent et en changeant juste une ligne pour spécifier continue outer1; au lieu de break outer1; va provoquer la boucle de continuer à Boucler de l'étiquette outer1 au lieu de sortir de la boucle. Notez que chaque fois que continue outer1; est appelé, le code continue à partir de la boucle externe après incrémentation de l'index de boucle i par 1.
outer1:
for(int i=0; i<5; i++) {
for(int j=0; j<4; j++) {
for(int k=0; k<2; k++) {
System.out.println("[" + i + "][" + j + "][" + k + "]");
if(j == 3) {
continue outer1;
}
}
}
[0][0][0]
[0][0][1]
[0][1][0]
[0][1][1]
[0][2][0]
[0][2][1]
[0][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[1][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[1][0][1]
[1][1][0]
[1][1][1]
[1][2][0]
[1][2][1]
[1][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[2][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[2][0][1]
[2][1][0]
[2][1][1]
[2][2][0]
[2][2][1]
[2][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[3][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[3][0][1]
[3][1][0]
[3][1][1]
[3][2][0]
[3][2][1]
[3][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[4][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[4][0][1]
[4][1][0]
[4][1][1]
[4][2][0]
[4][2][1]
[4][3][0]
Source: Boucles en Java – Guide Ultime
l'énoncé break est la structure de contrôle en boucle actuelle et saute derrière elle, tandis que le continue sort aussi, mais revient à la condition de boucle.
pour empêcher quoi que ce soit de l'exécution si une condition est respectée, on devrait utiliser la suite et pour sortir de la boucle si une condition est respectée, on devrait utiliser la pause.
par exemple dans le code mentionné ci-dessous.
for(int i=0;i<5;i++){
if(i==3){
continue;
}
System.out.println(i);
}
le code ci-dessus affichera le résultat : 0 1 2 4
considérez maintenant ce code
for(int i=0;i<5;i++){
if(i==3){
break;
}
System.out.println(i);
}
ce code s'affichera 0 1 2
C'est la base différence dans la suite et la rupture.
voici la sémantique de break:
int[] a = new int[] { 1, 3, 4, 6, 7, 9, 10 };
// find 9
for(int i = 0; i < a.Length; i++)
{
if (a[i] == 9)
goto goBreak;
Console.WriteLine(a[i].ToString());
}
goBreak:;
voici la sémantique de continuer:
int[] a = new int[] { 1, 3, 4, 6, 7, 9, 10 };
// skip all odds
for(int i = 0; i < a.Length; i++)
{
if (a[i] % 2 == 1)
goto goContinue;
Console.WriteLine(a[i].ToString());
goContinue:;
}
tout d'Abord,je pense que vous devriez savoir qu'il existe deux types de break et continue en Java, qui sont étiquetés pause,sans étiquette pause,étiquetés continuer et non continuer.Maintenant, je vais parler de la différence entre eux.
class BreakDemo {
public static void main(String[] args) {
int[] arrayOfInts =
{ 32, 87, 3, 589,
12, 1076, 2000,
8, 622, 127 };
int searchfor = 12;
int i;
boolean foundIt = false;
for (i = 0; i < arrayOfInts.length; i++) {
if (arrayOfInts[i] == searchfor) {
foundIt = true;
break;//this is an unlabeled break,an unlabeled break statement terminates the innermost switch,for,while,do-while statement.
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at index " + i);
} else {
System.out.println(searchfor + " not in the array");
}
}
une instruction de coupure non marquée termine l'interrupteur le plus à l'intérieur ,pendant que ,pendant que ,do-while.
public class BreakWithLabelDemo {
public static void main(String[] args) {
search:
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
System.out.println(i + " - " + j);
if (j == 3)
break search;//this is an labeled break.To notice the lab which is search.
}
}
}
une coupure marquée met fin à une déclaration extérieure.si vous javac et java cette démo,vous aurez obtenez de l':
0 - 0
0 - 1
0 - 2
0 - 3
class ContinueDemo {
public static void main(String[] args) {
String searchMe = "peter piper picked a " + "peck of pickled peppers";
int max = searchMe.length();
int numPs = 0;
for (int i = 0; i < max; i++) {
// interested only in p's
if (searchMe.charAt(i) != 'p')
continue;//this is an unlabeled continue.
// process p's
numPs++;
}
System.out.println("Found " + numPs + " p's in the string.");
}
un énoncé continuer sans étiquette saute l'itération actuelle d'un énoncé for,while,do-while.
public class ContinueWithLabelDemo {
public static void main(String[] args) {
search:
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
System.out.println(i + " - " + j);
if (j == 3)
continue search;//this is an labeled continue.Notice the lab which is search
}
}
}
une instruction continue étiquetée passe à côté de l'itération actuelle d'une boucle externe marquée avec le lable donné,si vous javac et java la démo, vous obtiendrez:
0 - 0
0 - 1
0 - 2
0 - 3
1 - 0
1 - 1
1 - 2
1 - 3
2 - 0
2 - 1
2 - 2
2 - 3
si vous avez une question , vous pouvez voir le tutoriel Java de ceci: entrez la description du lien ici
Exemple Simple:
break sort de la boucle.
int m = 0;
for(int n = 0; n < 5; ++n){
if(n == 2){
break;
}
m++;
}
System.out.printl("m:"+m); // m:2
continue retournera à la boucle de démarrage.
int m = 0;
for(int n = 0; n < 5; ++n){
if(n == 2){
continue; // Go back to start and dont execute m++
}
m++;
}
System.out.printl("m:"+m); // m:4
simplement mis: break terminera la boucle courante, et continuera l'exécution à la première ligne après la fin de la boucle. continuer saute de nouveau à la condition de boucle et continue d'exécuter la boucle.
for (int i = 1; i <= 3; i++) {
if (i == 2) {
continue;
}
System.out.print("[i:" + i + "]");
essayez ce code dans netbeans vous comprendrez la différence entre break et continue
for (int i = 1; i <= 3; i++) {
if (i == 2) {
break;
}
System.out.print("[i:" + i + "]");
programme Simple pour comprendre la différence entre continue et break
quand continue est utilisé
public static void main(String[] args) {
System.out.println("HelloWorld");
for (int i = 0; i < 5; i++){
System.out.println("Start For loop i = " + i);
if(i==2){
System.out.println("Inside if Statement for i = "+i);
continue;
}
System.out.println("End For loop i = " + i);
}
System.out.println("Completely out of For loop");
}
OutPut:
HelloWorld
Start For loop i = 0
End For loop i = 0
Start For loop i = 1
End For loop i = 1
Start For loop i = 2
Inside if Statement for i = 2
Start For loop i = 3
End For loop i = 3
Start For loop i = 4
End For loop i = 4
Completely out of For loop
quand break est utilisé
public static void main(String[] args) {
System.out.println("HelloWorld");
for (int i = 0; i < 5; i++){
System.out.println("Start For loop i = " + i);
if(i==2){
System.out.println("Inside if Statement for i = "+i);
break;
}
System.out.println("End For loop i = " + i);
}
System.out.println("Completely out of For loop");
}
Output:
HelloWorld
Start For loop i = 0
End For loop i = 0
Start For loop i = 1
End For loop i = 1
Start For loop i = 2
Inside if Statement for i = 2
Completely out of For loop
Continuer de Tresorerie arrêter l'itration et commencer à côté ittration Ex:
System.out.println("continue when i is 2:");
for (int i = 1; i <= 3; i++) {
if (i == 2) {
System.out.print("[continue]");
continue;
}
System.out.print("[i:" + i + "]");
}
et de Briser Déclaration d'arrêt de la boucle ou de Sortie de la boucle
donc vous êtes dans une boucle pour ou pendant. Utiliser break; vous placera en dehors de la boucle. Comme dans, ce sera la fin. Continuer; va dire à exécuter la prochaine itération.
Ne sert à continuer dans si l'état, mais break; est utile. En switch...case, Toujours utiliser break; pour terminer un cas, de sorte qu'il n'exécute pas un autre cas.