4.3 循環語句

循環語句在程序設計中有什么作用呢？

【實例4.7】下面先看一段簡單的程序段，再來看看使用循環語句編寫程序的好處在哪里。

01   ///將x連續加1加10次
02   public class control4
03   {
04       public static void main(String[] args)
05       {
06          int x=1;
07          x=x+1;
08          x=x+1;
09          x=x+1;
10          x=x+1;
11          x=x+1;
12          x=x+1;
13          x=x+1;
14          x=x+1;
15          x=x+1;
16          x=x+1;
17          System.out.println(x);
18       }
19   }

【代碼說明】代碼的含義是讓變量“x”連續加1共加10次。如果想要加1加100次，那要讓“x=x+1”這個表達式重復100次。

【運行效果】

11

這樣龐大的程序段所要完成的功能，不過是一個很簡單的相加功能。為了解決這類問題，程序設計中引入了循環語句。循環語句總共有3種常見的形式：for語句、while語句、do/while語句。下面將逐個進行詳細的介紹。

4.3.1 for語句

for語句的基本結構如下所示。

01   for(初始化表達式;判斷表達式;遞增（遞減）表達式)
02   {
03       執行語句
04   }

【實例4.8】針對for語句，來修改上面的程序段。

01   public class control5
02   {
03       public static void main(String[] args)
04       {
05            int x;
06            int n=10;
07            for( x=1;n>0;n--，x++)
08            {System.out.println(x);}
09       }
10   }

【代碼說明】在這個程序段里，用第5～8行共4句代碼完成了前面程序段里12句代碼所解決的事情。

【運行效果】

1
2
3
4
5
6
7
8
9
10

【實例4.9】如果前面的程序段中，需要連續加1加100次。則參考下面的程序段。

01   public class control6
02   {
03       public static void main(String[] args)
04       {
05           int x;
06           int n=100;
07           for(x=1;n>0;n--，x++){}
08           System.out.println(x);
09       }
10   }

【代碼說明】在這個程序段里，使用第5～8行共4句代碼可以解決前面程序段中12句代碼所解決的問題，這就是循環語句的優勢。

【運行效果】

101

下面詳細地解釋for循環語句中各個子項的意義。

?初始化表達式：初始化表達式的意義，在于定義循環之前變量的值是多少，如果沒有這一項，就不知道該從哪個值開始循環。

?判斷表達式：判斷表達式的作用在于規定循環的終點。如果沒有判斷表達式，那么此循環就成了死循環。

?遞增（遞減）表達式：這一項規定每執行一次程序，變量以多少增量或減量進行變化。

其實也可以利用在條件判斷語句中提到的流程圖來編寫程序，在流程圖中可以看出程序運行的順序，如圖4.4所示。

【實例4.10】下面再看一個九九乘法表的程序段。先來繪制流程圖，如圖4.5所示。

根據流程圖，使用循環語句編寫一個乘法口訣表。

01   ///這是一個多重for循環語句
02   public class control7
03   {
04       public static void main(String[] args)
05       {
06           for(int x=2;x<10;x++)
07            {
08                 for(int y=1;y<10;y++)
09                 {
10                      System.out.print(x+"＊"+y+"="+(x＊y));
11                      System.out.print("");
12                 }
13            System.out.println("");
14            }
15        }
16   }

【代碼說明】第6～14行是外圍的for循環，第8～12行是一個嵌入在外圍循環中的循環，這樣的我們稱之為嵌套循環。為什么要使用兩重循環呢？因為它涉及兩個變化的量。在一個程序里，有多少個不同變量，就要使用多少個for循環，當然也不是非常絕對的。

【運行效果】

2＊1=22＊2=42＊3=62＊4=82＊5=102＊6=122＊7=142＊8=162＊9=18
3＊1=33＊2=63＊3=93＊4=123＊5=153＊6=183＊7=213＊8=243＊9=27
4＊1=4 4＊2=8 4＊3=12 4＊4=16 4＊5=20 4＊6=24 4＊7=28 4＊8=32 4＊9=36
5＊1=5 5＊2=10 5＊3=15 5＊4=20 5＊5=25 5＊6=30 5＊7=35 5＊8=40 5＊9=45
6＊1=2 6＊2=12 6＊3=18 6＊4=24 6＊5=30 6＊6=36 6＊7=42 6＊8=48 6＊9=54
7＊1=7 7＊2=14 7＊3=21 7＊4=28 7＊5=35 7＊6=42 7＊7=49 7＊8=56 7＊9=63
8＊1=8 8＊2=16 8＊3=24 8＊4=32 8＊5=40 8＊6=48 8＊7=56 8＊8=64 8＊9=72
9＊1=9 9＊2=18 9＊3=27 9＊4=36 9＊5=45 9＊6=54 9＊7=63 9＊8=72 9＊9=81

在上面的程序段中，使用了嵌套for語句。其實真正復雜的程序段中，可能會出現4個嵌套的for語句，這要在實踐中慢慢體會。

4.3.2 while循環

在英文中“while”這個詞的意思是“當”，而在Java程序設計中，也可以將其理解為“當”。其語法結構是：

01   while (條件)
02   {
03       目的一;
04       目的二;
05       ...
06   }

當滿足某種條件，就執行“目的一”、“目的二”等，while語句的循環體在{}中。

【實例4.11】下面看一段程序段，通過分析它，讓讀者更加清楚循環語句。

01   ///通過判斷y是否大于0
02   ///如果y大于0則將計費次數減1，x加1
03   public class control8
04   {
05       public static void main(String[] args)
06       {
07           int x=0;
08           int y=100;
09           int sum=0;
10           while(y>0)
11           {
12               x=x+1;
13               y--;
14               sum+=x;
15           }
16           System.out.println(sum);
17      }
18   }

【代碼說明】這個程序段是將數字從1一直加到100，條件是只要“y”大于0，就會執行大括號里的語句。“y”初始值是100，滿足條件，所以執行大括號的表達式。先將“x+1”賦給“x”，因為x的初始值是0，所以x從1開始計數，然后，將“y”自減1，此時“y”變成了99，將“sum”加上“x”賦給“sum”。此時，執行語句結束了，又會回到小括號的條件，最后再比較“y=99”是否大于0，如果大于0，再繼續執行大括號里的語句。

一旦“y”自減到小于0，則將結束執行大括號里的語句，開始執行大括號外的語句。在上面的程序段中，y就相當于一個計數器。

【運行效果】

5050

同樣，在編寫while語句時，要先繪制流程圖，根據流程圖再來編寫程序段，整個思路就會很清晰了。下面先看while的流程圖，如圖4.6所示。

其實while語句很簡單，根據這個流程圖，就可以思路很清晰地編寫程序段。下面針對上面的程序段來繪制流程圖，如圖4.7所示。

看了這個流程圖，會發現按照流程圖來編寫程序簡單多了。為了鞏固以上所說，再看一個例子。

【實例4.12】試編寫程序實現輸出1～100間的整數，并且此整數必須滿足：它是3的倍數，但不是5的倍數，也不是9的倍數。針對這個例子，先來繪制一個流程圖，如圖4.8所示。

根據流程圖，現在來編寫程序段。

01   ///通過判斷是否在100以內，并且是3的倍數
02   ///然后再判斷這些數是否不是5的倍數
03   ///最后判斷這些數是否不是9的倍數
04   public class control9
05   {
06       public static void main(String[] args)
07       {
08           int x=1;
09           while(((3＊x>1)&&(3＊x<100)))
10            {
11                if((3＊x)%5!=0)
12                {
13                     if((3＊x)%9!=0)
14                     {
15                          System.out.println(3＊x);
16                     }
17                }
18           x++;
19           }
20       }
21   }

【代碼說明】第9行是一個循環判斷條件，判斷是否在100以內，并且是3的倍數。第11行是一個條件語句，判斷這些數是否不是5的倍數，第13行也是一個條件語句，判斷這些數是否不是9的倍數。

【運行效果】

3
6
12
21
24
33
39
42
48
51
57
66
69
78
84
87
93
96

按照先繪制流程圖，后編寫程序的步驟，會顯得思路更清晰。其實從上面的程序段中，可以總結一點：當由多個條件形成循環條件時，可以選擇其中一個作為循環條件，而剩下的條件可以在循環體中作條件語句。

4.3.3 do...while語句

在學習do...while語句之前，先清楚while語句是如何工作的。while語句是先進行條件判斷，再執行大括號內的循環體。do...while語句與while語句不同的是，它先執行大括號內的循環體，再判斷條件，如果條件不滿足，下次不再執行循環體。也就是說，在判斷條件之前，就已經執行大括號內的循環體。

【實例4.13】下面先看一個程序段。

01   ///通過先判斷這個數是否是3的倍數，并且是否是5的倍數
02   ///再判斷是否是9的倍數
03   ///最后判斷是否在 100以內
04   public class control10
05   {
06       public static void main(String[] args)
07       {
08           int x=1;
09           do
10           {
11                if((3＊x)%5!=0)
12                {
13                     if((3＊x)%9!=0)
14                     {System.out.println(3＊x);}
15                }
16                x++;
17           }
18           while(((3＊x>1)&&(3＊x<100)));
19      }
20   }

【運行效果】

3
6
12
21
24
33
39
42
48
51
57
66
69
78
84
87
93
96

【代碼說明】從上面的程序段輸出結果可以看出，與使用while語句的輸出結果是一樣的，為什么會是一樣的呢？下面來分析：

當“x=33”時，先不會檢驗“3*33=99”是否小于100，而會先執行大括號內的循環體。當檢測到99是9的倍數時，條件是“false”，于是就會退出條件語句，繼續執行“x”自加1表達式，于是“x”變成了34，由于“34*3=102”大于100，所以結束循環體。因此程序執行到“x=32”后就無輸出了，最后輸出的結果當然和while語句的輸出一樣。

其實在實際程序開發中，不經常使用do...while循環語句。因為這種語句是先執行循環體再檢測條件，所以會有一些危險數據不經檢測，就會被執行。建議使用while語句或者for循環語句來編寫代碼。