break和continue语句的区别

StackOverflow https://stackoverflow.com/questions/462373

  •  19-08-2019
  •  | 
  •  

题

谁能告诉我break和continue语句之间的区别？

有帮助吗？

解决方案

break离开环，continue跳到下一迭代。

其他提示

请参阅的分支语句信息 对于更多的细节和代码示例：

break

  

break语句有两种形式：标记和未标记。你看到了   未标记的形式switch语句的前面的讨论。您   也可以使用未标记的突破终止了，同时，还是做，而   环[...]

     

这是未标记的break语句终止最内侧开关，用于，   同时，或do-while语句，但标签的break终止外   言。

continue

  

continue语句跳过的当前迭代，同时，   或do-while循环。未标记的形式跳过到最里面的端部   循环体并评估其控制的布尔表达式   环。 [...]

     

标记为A继续声明跳过标记与所述给定标签的外循环的当前迭代。

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");

这将导致下面的输出：

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

可以标记一个块，不仅一个for循环，然后打破/从嵌套块继续到外一个。在少数情况下，这可能是有用的，但总的来说，你会尽量避免这样的代码，除了程序的逻辑是远好于下面的例子就明白了：

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));
        }
    }       
}

由于这是可能的，但这并不意味着你应该使用它。

如果你想混淆你的代码中一个有趣的方式，你不选择meanigful的名字，但HTTP：和一个评论，它看起来外星人一样，在源代码中的webadress遵循它：

http://stackoverflow.com/questions/462373
for (int i = 0; i < 4; ++i) 
{
     if (i == 2) 
         break http;

我想这是从约书亚布洛赫quizzle。 :)

歇完全离开循环并执行循环后的语句。 而继续离开当前迭代，并与环中的下一个值执行。

  

此代码解释一切：

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");
    }
}

输出：

0   1   2   3   
0   1   2   3   5   6   7   8   9

break完全退出循环。 continue跳过报表后的继续的声明，并不断循环。

<强> break语句

有时有必要退出循环循环完成之前完全迭代所有的步长值。例如，遍历号码列表，直到找到一个数字，满足一定条件。或遍历字符流从一个文件，直到某个字符被读取。

在下面的例子中，我们使用一个简单的for循环，打印出的值从0到9：

for(int i=0; i<10; i++) {
  System.out.println(i);
}

输出：

0
1
2
3
4
5
6
7
8
9

现在，如果我们添加一个break语句时，我== 4，我们的代码会跳出循环一次，我等于4。您可以使用break语句打出来的for循环，while循环和do-while循环。 break语句只会跳出当前的循环。为了打破从嵌套内环的外环的，你将需要与break语句使用的标签。

for(int i=0; i<10; i++) {
  System.out.println(i);
  if(i==4) {
    break;
  }
}

输出：

0
1
2
3
4

继续声明

Java的 continue语句跳过循环的当前迭代，并直接进入下一次迭代。调用continue语句在for循环之后，循环执行会执行步长值，并与下一次迭代继续之前评估布尔条件。在下面的例子中，我们打印出从0所有值至9在一个循环中，但我们跳过打印出4。

for(int i=0; i<10; i++) {
  if(i==4) {
    continue;
  }
  System.out.println(i);
}

输出：

0
1
2
3
5 <---- SKIPPED OVER 4 and continued with next loop iteration
6
7
8
9

<强>循环标签 - break语句 您可以通过指定的您要执行，以突破后继续嵌套循环中使用标签的内循环。通常情况下，break语句只会跳出最内层循环的，所以当你想摆脱外环的，你可以使用标签来做到这一点，基本上是在做类似goto语句的东西。

下面的例子使用3个环，所有相互嵌套。由于没有办法完全从最内部循环中跳出最外层循环的，我们可以用标签“外围一号”要完成这一点，并指定标签break语句旁边。

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;
      }
    }
  }
}

输出：

[0][0][0]
[0][0][1]
[0][1][0]
[0][1][1]
[0][2][0]
[0][2][1]
[0][3][0]

注意显示的最后一行是如何“ 0 [0]”，其是其中j == 3而这也正是我们称为“中断外围一号;”打出来的最外回路的

<强>循环标签 - 继续声明

您也可以使用标签将继续关键字继续从特定点循环。以前面的例子，只是改变一个行指定continue outer1;代替break outer1;会导致循环继续从outer1标签循环，而不是终止循环的。注意每次continue outer1;是如何被调用，代码从外循环继续递增1环路索引i之后。

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]

来源：循环中的Java - 终极指南

优秀答案的简单，准确。

我想补充一个代码示例。

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

一个break语句结果在声明的终止其所适用（switch，for，do，或while）。

一个continue语句用于结束当前循环迭代，并将控制返回到循环语句。

continue跳过当前执行的环和<强>移动到下一的环的而break的移出的<强>环并执行在循环之后的下一个语句的。 我使用下面的代码学到的差异。检查出不同outputs.Hope这会有所帮助。

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

考虑如下：

int n;
for(n = 0; n < 10; ++n) {
    break;
}
System.out.println(n);

<强>断裂导致循环终止和的名词的是0。

的值 
int n;
for(n = 0; n < 10; ++n) {
    continue;
}
System.out.println(n);

继续导致程序计数器返回到循环的第一行（条件检查和n的值是增量）和最终值的名词的是10。

还应当指出的是的破仅终止循环的执行是内：

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);

将输出的东西的效果

0
0
0
0
0
5

在break语句跳出循环（将要执行的是闭括号后的第一个的下一个语句），而在continue在下一迭代开始循环。

的

在break语句存在当前循环控制结构，并跳转背后而continue退出太多，但跳回到循环条件。

简单示例：

break脱离其控制环。

int m = 0;
for(int n = 0; n < 5; ++n){
  if(n == 2){
    break;
  }
  m++;
}

System.out.printl("m:"+m); // m:2

continue将回到开始循环。

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

要防止执行任何东西，如果满足条件应该使用继续走出循环，如果条件满足，应该使用断点。

例如在下文提到的代码。

 for(int i=0;i<5;i++){

        if(i==3){

           continue;

        }
       System.out.println(i);
     }

上面的代码将打印结果：0 1 2 4

现在考虑下面的代码

 for(int i=0;i<5;i++){


            if(i==3){

                break;

            }
            System.out.println(i);
         }

这个代码将打印0 1 2

这是在继续和断裂。

的基本差

这里的断裂的语义：

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:;

这里的语义继续：

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:;
}

首先，我想你应该知道，有两种类型的破发，并继续在Java中被标记符，未标记突破，继续标记和未标记continue.Now，我会谈论他们之间的区别。

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");
    }
}

这是未标记的break语句终止最内侧开关，为同时，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.
        }
    }
}

一个标记的断裂终止外statement.if你javac和java本演示中，你将得到：

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.");
}

这是未标记的继续声明跳过的当前迭代，同时，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
        }
    }
}
标记

continue语句跳过标记与给定拉布勒外环的当前迭代，如果你javac和java演示中，您将获得：

0 - 0
0 - 1
0 - 2
0 - 3
1 - 0
1 - 1
1 - 2
1 - 3
2 - 0
2 - 1
2 - 2
2 - 3

如果您有任何问题，你可以看到这样的Java教程：的在这里输入的链接描述

简而言之：破将终止电流回路，并且在第一行继续执行循环结束后。继续跳回到循环条件和保持运行循环。

for (int i = 1; i <= 3; i++) {
        if (i == 2) {

            continue;
        }
        System.out.print("[i:" + i + "]");

尝试在NetBeans这个代码，你就会明白休息之间的不同，并继续

for (int i = 1; i <= 3; i++) {
        if (i == 2) {

            break;
        }
        System.out.print("[i:" + i + "]");

简单的程序来理解继续和断裂之间的差异

当continue使用

    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

当break使用

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

继续Statment停止itration，并开始下一次迭代 例如：

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 + "]");
    }

和分段Statment从回路停止循环或退出

所以你是内部的for或while循环。使用break;将让你的循环之外。如，这将结束。继续;会告诉它运行下一次迭代。

在使用if语句继续，但没有突破点;是非常有用的。 在开关...情况下，总是使用break;结束的情况下，因此它不执行另一个例子。

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top