java 循環語句

Java 的循環語句有for，while 和 do-while 。這些語句創造了我們通常所稱的循環（loops）。你可能知道，一個循環重復執行同一套指令直到一個結束條件出現。你將看到，Java 有適合任何編程所需要的循環結構。

5.2.1 while 語句
while 語句是Java 最基本的循環語句。當它的控制表達式是真時，while 語句重復執行一個語句或語句塊。它的通用格式如下：

while(condition) {
// body of loop
}

條件condition 可以是任何布爾表達式。只要條件表達式為真，循環體就被執行。當條件condition 為假時，程序控制就傳遞到循環后面緊跟的語句行。如果只有單個語句需要重復，大括號是不必要的。

下面的while 循環從10開始進行減計數，打印出10行“tick”。

// Demonstrate the while loop.
class While {
public static void main(String args[]) {
int n = 10;

while(n > 0) {
System.out.println("tick " + n);
n--;

}
}
}

當你運行這個程序，它將“tick”10次：

tick 10
tick 9
tick 8
tick 7
tick 6
tick 5
tick 4
tick 3
tick 2
tick 1

因為while 語句在循環一開始就計算條件表達式，若開始時條件為假，則循環體一次也不會執行。例如，下面的程序中，對println( ) 的調用從未被執行過：

int a = 10, b = 20;

while(a > b)
System.out.println("This will not be displayed");

while 循環（或Java 的其他任何循環）的循環體可以為空。這是因為一個空語句（null statement) （僅由一個分號組成的語句）在Java 的語法上是合法的。例如，下面的程序：

// The target of a loop can be empty.
class NoBody {
public static void main(String args[]) {

int i, j;

i = 100;
j = 200;

// find midpoint between i and j
while(++i < --j) ; // no body in this loop

System.out.println("Midpoint is " + i);
}
}

該程序找出變量i和變量j的中間點。它產生的輸出如下：

Midpoint is 150

該程序中的while 循環是這樣執行的。值i自增，而值j自減，然后比較這兩個值。如果新的值i仍比新的值j小，則進行循環。如果i等于或大于j，則循環停止。在退出循環前，i 將保存原始i和j的中間值（當然，這個程序只有在開始時i比j小的情況下才執行）。正如你看到的，這里不需要循環體。所有的行為都出現在條件表達式自身內部。在專業化的Java 代碼中，一些可以由控制表達式本身處理的短循環通常都沒有循環體。

5.2.2 do-while 循環
如你剛才所見，如果while 循環一開始條件表達式就是假的，那么循環體就根本不被執行。然而，有時需要在開始時條件表達式即使是假的情況下，while 循環至少也要執行一次。換句話說，有時你需要在一次循環結束后再測試中止表達式，而不是在循環開始時。幸運的是，Java 就提供了這樣的循環：do-while 循環。do-while 循環總是執行它的循環體至少一次，因為它的條件表達式在循環的結尾。它的通用格式如下：

do {
// body of loop
} while (condition);

do-while 循環總是先執行循環體，然后再計算條件表達式。如果表達式為真，則循環繼續。否則，循環結束。對所有的Java 循環都一樣，條件condition 必須是一個布爾表達式。下面是一個重寫的“tick”程序，用來演示do-while 循環。它的輸出與先前程序的輸出相同。

// Demonstrate the do-while loop.
class DoWhile {
public static void main(String args[]) {
int n = 10;

do {
System.out.println("tick " + n);
n--;

} while(n > 0);
}
}

該程序中的循環雖然在技術上是正確的，但可以像如下這樣編寫更為高效：

do {
System.out.println("tick " + n);
} while(--n > 0);

在本例中，表達式“-- n > 0 ”將n值的遞減與測試n是否為0組合在一個表達式中。它的執行過程是這樣的。首先，執行-- n 語句，將變量n遞減，然后返回n的新值。這個值再與0比較，如果比0大，則循環繼續。否則結束。

do-while 循環在你編制菜單選擇時尤為有用，因為通常都想讓菜單循環體至少執行一次。下面的程序是一個實現Java 選擇和重復語句的很簡單的幫助系統：

// Using a do-while to process a menu selection
class Menu {

public static void main(String args[])
throws java.io.IOException {
char choice;

do {
System.out.println("Help on:");
System.out.println(" 1. if");
System.out.println(" 2. switch");
System.out.println(" 3. while");
System.out.println(" 4. do-while");
System.out.println(" 5. for\n");
System.out.println("Choose one:");
choice = (char) System.in.read();

} while( choice < '1' || choice > '5');

System.out.println("\n");

switch(choice) {

case '1':
System.out.println("The if:\n");
System.out.println("if(condition) statement;");
System.out.println("else statement;");

break;

case '2':
System.out.println("The switch:\n");
System.out.println("switch(expression) {");
System.out.println(" case constant:");
System.out.println(" statement sequence");
System.out.println(" break;");
System.out.println(" // ...");
System.out.println("}");
break;

case '3':
System.out.println("The while:\n");
System.out.println("while(condition) statement;");
break;

case '4':
System.out.println("The do-while:\n");
System.out.println("do {");

System.out.println(" statement;");
System.out.println("} while (condition);");
break;

case '5':
System.out.println("The for:\n");
System.out.print("for(init; condition; iteration)");
System.out.println(" statement;");
break;

}
}
}

下面是這個程序執行的一個樣本輸出：

Help on:

1. if
2. switch
3. while
4. do-while
5. for
Choose one:
4
The do-while:
do {

statement;
} while (condition);

在程序中，do-while 循環用來驗證用戶是否輸入了有效的選擇。如果沒有，則要求用戶重新輸入。因為菜單至少要顯示一次，do-while 循環是完成此任務的合適語句。

關于此例的其他幾點：注意從鍵盤輸入字符通過調用System.in.read( ) 來讀入。這是一個Java 的控制臺輸入函數。盡管Java 的終端 I/O （輸入/輸出)方法將在第12章中詳細討論，在這里使用System.in.read ( ) 來讀入用戶的選擇。它從標準的輸入讀取字符（返回整數，因此將返回值choice 定義為字符型）。默認地，標準輸入是按行進入緩沖區的，因此在你輸入的任何字符被送到你的程序以前，必須按回車鍵。

Java 的終端輸入功能相當有限且不好使用。進一步說，大多數現實的Java 程序和applets （小應用程序）都具有圖形界面并且是基于窗口的。因此，這本書使用終端的輸入并不多。然而，它在本例中是有用的。另外一點:因為使用System.in.read ( ) ，程序必須指定throws java.io.IOException 子句。這行代碼對于處理輸入錯誤是必要的。這是Java 的異常處理的一部分，將在第10章討論。

5.2.3 for 循環
在第2章曾使用過一個for循環的簡單格式。你將看到，for循環是一個功能強大且形式靈活的結構。下面是for 循環的通用格式：

for(initialization; condition; iteration) {
// body
}

如只有一條語句需要重復，大括號就沒有必要。

for循環的執行過程如下。第一步，當循環啟動時，先執行其初始化部分。通常，這是設置循環控制變量值的一個表達式，作為控制循環的計數器。重要的是你要理解初始化表達式僅被執行一次。下一步，計算條件condition 的值。條件condition 必須是布爾表達式。它通常將循環控制變量與目標值相比較。如果這個表達式為真，則執行循環體；如果為假，則循環終止。再下一步執行循環體的反復部分。這部分通常是增加或減少循環控制變量的一個表達式。接下來重復循環，首先計算條件表達式的值，然后執行循環體，接著執行反復表達式。這個過程不斷重復直到控制表達式變為假。

下面是使用for 循環的“tick”程序：

// Demonstrate the for loop.
class ForTick {
public static void main(String args[]) {
int n;

for(n=10; n>0; n--)
System.out.println("tick " + n);
}
}

在for 循環中聲明循環控制變量

控制for循環的變量經常只是用于該循環，而不用在程序的其他地方。在這種情況下，可以在循環的初始化部分中聲明變量。例如，下面重寫了前面的程序，使變量 n 在for循環中被聲明為整型：

// Declare a loop control variable inside the for.
class ForTick {
public static void main(String args[]) {

// here, n is declared inside of the for loop
for(int n=10; n>0; n--)
System.out.println("tick " + n);
}
}

當你在for 循環內聲明變量時，必須記住重要的一點:該變量的作用域在for語句執行后就結束了（因此，該變量的作用域就局限于for 循環內）。在for循環外，變量就不存在了。如果你在程序的其他地方需要使用循環控制變量，你就不能在for循環中聲明它。

由于循環控制變量不會在程序的其他地方使用，大多數程序員都在for循環中來聲明它。例如，以下為測試素數的一個簡單程序。注意由于其他地方不需要i，所以循環控制變量i在for循環中聲明。

// Test for primes.
class FindPrime {

public static void main(String args[]) {
int num;
boolean isPrime = true;

num = 14;

for(int i=2; i <= num/2; i++) {

if((num % i) == 0) {
isPrime = false;
break;

}
}
if(isPrime) System.out.println("Prime");
else System.out.println("Not Prime");

}
}

使用逗號

你可能經常需要在初始化和for循環的反復部分包括超過一個變量的聲明。例如，考慮下面程序的循環部分：

class Sample {

public static void main(String args[]) {
int a, b;
b = 4;
for(a=1; a<b; a++) {

System.out.println("a = " + a);
System.out.println("b = " + b);
b--;

}
}
}

如你所看到的，循環被兩個相互作用的變量控制。由于循環被兩個變量控制，如果兩個變量都能被定義在for 循環中，而變量b不需要通過人工處理將是很有用的。幸好，Java 提供了一個完成此任務的方法。為了允許兩個或兩個以上的變量控制循環，Java 允許你在for 循環的初始化部分和反復部分聲明多個變量，每個變量之間用逗號分開。

使用逗號，前面的for循環將更高效，改寫后的程序如下：

// Using the comma.
class Comma {
public static void main(String args[]) {
int a, b;

for(a=1, b=4; a<b; a++, b--) {System.out.println("a = " + a);System.out.println("b = " + b);

}
}
}

在本例中，初始化部分把兩個變量a和 b都定義了。在循環的反復部分，用兩個逗號分開的語句在每次循環重復時都執行。程序輸出如下：

a = 1
b = 4
a = 2
b = 3

注意：如果你對C/C++ 熟悉，你就會知道逗號是一個運算符，能在任何有效的表達

式中使用。然而，在Java 中不是這樣。在 Java 中，逗號僅僅是一個分隔符，只

適用于for循環。

5.2.4 for 循環的一些變化
for循環支持一些變化，這增加了它的功能和靈活性。for循環這樣靈活是因為它的3部分（初始化部分，條件測試部分和反復部分）并不僅用于它們所限定的那些目的。事實上，for 循環的3部分能被用于你需要的任何目的。讓我們看一些例子。

最普通的變化之一包含在條件表達式中。具體地說，條件表達式可以不需要用循環變量和目標值的比較來測試循環條件。事實上，控制for 循環的條件可以是任何布爾表達式。例如，考慮下列程序片段：

boolean done = false;

for(int i=1; !done; i++) {

// ...

if(interrupted()) done = true;

}

在本例中，for循環將一直運行，直到布爾型變量done 被設置為真。for循環的條件部分不測試值i。

下面是for循環的另外一個有趣的變化。在Java 中可以使for循環的初始化、條件或者反復部分中的任何或者全部都為空，如下面的程序：

// Parts of the for loop can be empty.

class ForVar {

public static void main(String args[]) {

int i;

boolean done = false;

i = 0;

for( ; !done; ) {

System.out.println("i is " + i);

if(i == 10) done = true;

i++;}}

}

本例中，初始化部分和反復部分被移到了for 循環以外。這樣，for循環的初始化部分和反復部分是空的。當這個簡單的例子中，for循環中沒有值，確實，這種風格被認為是相當差的，有時這種風格也是有用的。例如，如果初始條件由程序中其他部分的復雜表達式來定義，或者循環控制變量的改變由發生在循環體內的行為決定，而且這種改變是一種非順序的方式，這種情況下，可以使for 循環的這些部分為空。

下面是for 循環變化的又一種方式。如果for循環的三個部分全為空，你就可以創建一個無限循環（從來不停止的循環）。例如：

for( ; ; ) {
// ...
}

這個循環將始終運行，因為沒有使它終止的條件。盡管有一些程序，例如操作系統命令處理器，需要無限循環，但大多數“無限循環”實際上是具有特殊終止要求的循環。在不久你將看到如何不用正常的條件表達式來終止這種類型的循環。

5.2.5 循環嵌套
和其他編程語言一樣，Java 允許循環嵌套。也就是，一個循環在另一個循環之內。例如，下面的程序就是循環嵌套：

// Loops may be nested.
class Nested {
public static void main(String args[]) {
int i, j;

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

該程序產生的輸出如下所示：

. . . . . . . . . .
. . . . . . . . .
. . . . . . . .
. . . . . . .
. . . . . .
. . . . .
. . . .
. . .
. .
.

原文轉自：http://www.kjueaiud.com