当前位置: 首页 > 编程语言 > Java > 正文

java的break和continue语句

时间:2007-05-28 yycnet.yeah.net yyc译

在任何循环语句的主体部分,亦可用break和continue控制循环的流程。其中,break用于强行退出循环,不执行循环中剩余的语句。而continue则停止执行当前的反复,然后退回循环起始和,开始新的反复。
下面这个程序向大家展示了break和continue在for和while循环中的例子:

 

//: BreakAndContinue.java
// Demonstrates break and continue keywords

public class BreakAndContinue {
  public static void main(String[] args) {
    for(int i = 0; i < 100; i++) {
      if(i == 74) break; // Out of for loop
      if(i % 9 != 0) continue; // Next iteration
      System.out.println(i);
    }
    int i = 0;
    // An "infinite loop":
    while(true) {
      i++;
      int j = i * 27;
      if(j == 1269) break; // Out of loop
      if(i % 10 != 0) continue; // Top of loop
      System.out.println(i);
    }
  }
} ///:~


在这个for循环中,i的值永远不会到达100。因为一旦i到达74,break语句就会中断循环。通常,只有在不知道中断条件何时满足时,才需象这样使用break。只要i不能被9整除,continue语句会使程序流程返回循环的最开头执行(所以使i值递增)。如果能够整除,则将值显示出来。
第二部分向大家揭示了一个“无限循环”的情况。然而,循环内部有一个break语句,可中止循环。除此以外,大家还会看到continue移回循环顶部,同时不完成剩余的内容(所以只有在i值能被9整除时才打印出值)。输出结果如下:

 

0
9
18
27
36
45
54
63
72
10
20
30
40


之所以显示0,是由于0%9等于0。
无限循环的第二种形式是for(;;)。编译器将while(true)与for(;;)看作同一回事。所以具体选用哪个取决于自己的编程习惯。

1. 臭名昭著的“goto”
goto关键字很早就在程序设计语言中出现。事实上,goto是汇编语言的程序控制结构的始祖:“若条件A,则跳到这里;否则跳到那里”。若阅读由几乎所有编译器生成的汇编代码,就会发现程序控制里包含了许多跳转。然而,goto是在源码的级别跳转的,所以招致了不好的声誉。若程序总是从一个地方跳到另一个地方,还有什么办法能识别代码的流程呢?随着Edsger Dijkstra著名的“Goto有害”论的问世,goto便从此失宠。
事实上,真正的问题并不在于使用goto,而在于goto的滥用。而且在一些少见的情况下,goto是组织控制流程的最佳手段。
尽管goto仍是Java的一个保留字,但并未在语言中得到正式使用;Java没有goto。然而,在break和continue这两个关键字的身上,我们仍然能看出一些goto的影子。它并不属于一次跳转,而是中断循环语句的一种方法。之所以把它们纳入goto问题中一起讨论,是由于它们使用了相同的机制:标签。
“标签”是后面跟一个冒号的标识符,就象下面这样:
label1:
对Java来说,唯一用到标签的地方是在循环语句之前。进一步说,它实际需要紧靠在循环语句的前方——在标签和循环之间置入任何语句都是不明智的。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另一个循环或者一个开关。这是由于break和continue关键字通常只中断当前循环,但若随同标签使用,它们就会中断到存在标签的地方。如下所示:

label1:
外部循环{
内部循环{
//...
break; //1
//...
continue; //2
//...
continue label1; //3
//...
break label1; //4
}
}

在条件1中,break中断内部循环,并在外部循环结束。在条件2中,continue移回内部循环的起始处。但在条件3中,continue label1却同时中断内部循环以及外部循环,并移至label1处。随后,它实际是继续循环,但却从外部循环开始。在条件4中,break label1也会中断所有循环,并回到label1处,但并不重新进入循环。也就是说,它实际是完全中止了两个循环。
下面是for循环的一个例子:

 

//: LabeledFor.java
// Java’s "labeled for loop"

public class LabeledFor {
  public static void main(String[] args) {
    int i = 0;
    outer: // Can't have statements here
    for(; true ;) { // infinite loop
      inner: // Can't have statements here
      for(; i < 10; i++) {
        prt("i = " + i);
        if(i == 2) {
          prt("continue");
          continue;
        }
        if(i == 3) {
          prt("break");
          i++; // Otherwise i never
               // gets incremented.
          break;
        }
        if(i == 7) {
          prt("continue outer");
          i++; // Otherwise i never
               // gets incremented.
          continue outer;
        }
        if(i == 8) {
          prt("break outer");
          break outer;
        }
        for(int k = 0; k < 5; k++) {
          if(k == 3) {
            prt("continue inner");
            continue inner;
          }
        }
      }
    }
    // Can't break or continue
    // to labels here
  }
  static void prt(String s) {
    System.out.println(s);
  }
} ///:~


这里用到了在其他例子中已经定义的prt()方法。
注意break会中断for循环,而且在抵达for循环的末尾之前,递增表达式不会执行。由于break跳过了递增表达式,所以递增会在i==3的情况下直接执行。在i==7的情况下,continue outer语句也会到达循环顶部,而且也会跳过递增,所以它也是直接递增的。
下面是输出结果:

 

i = 0
continue inner
i = 1
continue inner
i = 2
continue
i = 3
break
i = 4
continue inner
i = 5
continue inner
i = 6
continue inner
i = 7
continue outer
i = 8
break outer

如果没有break outer语句,就没有办法在一个内部循环里找到出外部循环的路径。这是由于break本身只能中断最内层的循环(对于continue同样如此)。
当然,若想在中断循环的同时退出方法,简单地用一个return即可。
下面这个例子向大家展示了带标签的break以及continue语句在while循环中的用法:

 

//: LabeledWhile.java
// Java's "labeled while" loop

public class LabeledWhile {
  public static void main(String[] args) {
    int i = 0;
    outer:
    while(true) {
      prt("Outer while loop");
      while(true) {
        i++;
        prt("i = " + i);
        if(i == 1) {
          prt("continue");
          continue;
        }
        if(i == 3) {
          prt("continue outer");
          continue outer;
        }
        if(i == 5) {
          prt("break");
          break;
        }
        if(i == 7) {
          prt("break outer");
          break outer;
        }
      }
    }
  }
  static void prt(String s) {
    System.out.println(s);
  }
} ///:~

同样的规则亦适用于while:
(1) 简单的一个continue会退回最内层循环的开头(顶部),并继续执行。
(2) 带有标签的continue会到达标签的位置,并重新进入紧接在那个标签后面的循环。
(3) break会中断当前循环,并移离当前标签的末尾。
(4) 带标签的break会中断当前循环,并移离由那个标签指示的循环的末尾。
这个方法的输出结果是一目了然的:
 

Outer while loop
i = 1
continue
i = 2
i = 3
continue outer
Outer while loop
i = 4
i = 5
break
Outer while loop
i = 6
i = 7
break outer

大家要记住的重点是:在Java里唯一需要用到标签的地方就是拥有嵌套循环,而且想中断或继续多个嵌套级别的时候。
在Dijkstra的“Goto有害”论中,他最反对的就是标签,而非goto。随着标签在一个程序里数量的增多,他发现产生错误的机会也越来越多。标签和goto使我们难于对程序作静态分析。这是由于它们在程序的执行流程中引入了许多“怪圈”。但幸运的是,Java标签不会造成这方面的问题,因为它们的活动场所已被限死,不可通过特别的方式到处传递程序的控制权。由此也引出了一个有趣的问题:通过限制语句的能力,反而能使一项语言特性更加有用。