一、循環結構
循環語句可以在滿足循環條件的情況下，反復執行某一段代碼，這段被重復執行的代碼被稱為循環體語句，當反復執行這個循環體時，需要在合適的時候把循環判斷條件修改為false，從而結束循環，否則循環將一直執行下去，形成死循環。
循環語句的組成：
初始化語句：一條或者多條語句，這些語句完成一些初始化操作。
判斷條件語句：這是一個boolean 表達式，這個表達式能決定是否執行循環體。
循環體語句：這個部分是循環體語句，也就是我們要多次做的事情。
控制條件語句：這個部分在一次循環體結束后，下一次循環判斷條件執行前執行。通過用于控制循環條件中的變量，使得循環在合適的時候結束。
eg：在控制臺輸出10次"HelloWorld"時，
初始化語句：定義初始化為第一次。
判斷條件語句：次數不能超過10次。
循環體語句：輸出”HelloWorld”語句。
控制條件語句：次數變化為下一次。
二、循環結構(for循環語句)
for循環語句格式：
for(初始化語句;判斷條件語句;控制條件語句) {
循環體語句;
}
執行流程：
A:執行初始化語句
B:執行判斷條件語句，看其結果是true還是false：如果是false，循環結束；如果是true，繼續執行。
C:執行循環體語句
D:執行控制條件語句
E:回到B繼續
流程圖：
注意事項：
（1）判斷條件語句的結果是一個boolean類型
（2）循環體語句如果是一條語句，大括號可以省略；如果是多條語句，大括號不能省略。建議永遠不要省略。
（3）一般來說：有左大括號就沒有分號，有分號就沒有左大括號
代碼舉例：
1、求出1-100之間偶數和：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
/* 需求： A:求1-100之和。 B:求出1-100之間偶數和*/class ForTest1 { public static void main(String[] args) { //求1-100之和。 int sum1 = 0; for(int x=1; x<=100; x++) { sum1 +=x; } System.out.println("1-100之和是："+sum1); System.out.println("------------------"); //求出1-100之間偶數和 //方式1 int sum2 = 0; for(int x=1; x<=100; x++) { if(x%2 == 0) { sum2 += x; } } System.out.println("1-100偶數之和是："+sum2); System.out.println("------------------"); //方式2 int sum3 = 0; for(int x=0; x<=100; x+=2) { sum3 += x; } System.out.println("1-100偶數之和是："+sum3); System.out.println("------------------"); }} |
2、求5的階乘：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
/* 需求：求5的階乘。 什么是階乘呢? n! = n*(n-1)! 規則 n! = n*(n-1)*(n-2)*...*3*2*1 求和思想。 求階乘思想。*/class ForTest2 { public static void main(String[] args) { //定義最終結果變量 int jc = 1; //這里的x其實可以直接從2開始 //for(int x=1; x<=5; x++) for(int x=2; x<=5; x++) { jc *=x; } System.out.println("1-5的階乘是："+jc); }} |
3、在控制臺輸出所有的“水仙花數”：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
/* 需求：在控制臺輸出所有的”水仙花數” 分析： 我們都不知道什么叫"水仙花數"，你讓我怎么做呢? 所謂的水仙花數是指一個三位數，其各位數字的立方和等于該數本身。 舉例：153就是一個水仙花數。 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153 A:三位數其實是告訴了我們范圍。 B:通過for循環我們就可以實現獲取每一個三位數 但是麻煩是如何獲取這個三位數的個,十,百位上的數據 我們如何獲取一個數據的個,十,百呢? 假設有個一個數據:153 ge: 153%10 = 3 shi: 153/10%10 = 5 bai：153/10/10%10 = 1 qian：x/10/10/10%10 wan: x/10/10/10/10%10 ... C:讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該數據比較 如果相同，就把該數據在控制臺輸出。*/class ForTest3 { public static void main(String[] args) { //三位數其實是告訴了我們范圍。 for(int x=100; x<1000; x++) { int ge = x%10; int shi = x/10%10; int bai = x/10/10%10; //讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該數據比較 if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) { //如果相同，就把該數據在控制臺輸出。 System.out.println(x); } } }} |
三、循環結構(while循環語句)
while循環語句格式：
while(判斷條件語句) {
循環體語句;
}
//擴展格式
初始化語句;
while(判斷條件語句) {
循環體語句;
控制條件語句;
}
流程圖：
for循環和while循環的區別：
for循環語句和while循環語句可以等價轉換，但還是有些小區別的。
（1）使用區別：
控制條件語句所控制的那個變量，在for循環結束后，就不能再被訪問到了，而while循環結束還可以繼續使用，如果你想繼續使用，就用while，否則推薦使用for。原因是for循環結束，該變量就從內存中消失，能夠提高內存的使用效率。
（2）場景區別：
for循環適合針對一個范圍判斷進行操作while循環適合判斷次數不明確操作
代碼舉例：
我國最高山峰是珠穆朗瑪峰：8848m，我現在有一張足夠大的紙張，厚度為：0.01m。請問，我折疊多少次，就可以保證厚度不低于珠穆朗瑪峰的高度?
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
/* 我國最高山峰是珠穆朗瑪峰：8848m，我現在有一張足夠大的紙張，厚度為：0.01m。 請問，我折疊多少次，就可以保證厚度不低于珠穆朗瑪峰的高度? 分析： A:定義一個統計變量，默認值是0 B:最高山峰是珠穆朗瑪峰：8848m這是最終的厚度 我現在有一張足夠大的紙張，厚度為：0.01m這是初始厚度 C:我折疊多少次，就可以保證厚度不低于珠穆朗瑪峰的高度? 折疊一次有什么變化呢?就是厚度是以前的2倍。 D:只要每次變化的厚度沒有超過珠穆朗瑪峰的高度，就折疊，統計變量++ E:輸出統計變量。*/class WhileTest01 { public static void main(String[] args) { //定義一個統計變量，默認值是0 int count = 0; //最高山峰是珠穆朗瑪峰：8848m這是最終的厚度 //我現在有一張足夠大的紙張，厚度為：0.01m這是初始厚度 //為了簡單，我把0.01變成1，同理8848就變成了884800 int end = 884800; int start = 1; while(start<end) { //只要每次變化的厚度沒有超過珠穆朗瑪峰的高度，就折疊，統計變量++ count++; //折疊一次有什么變化呢?就是厚度是以前的2倍。 start *= 2; System.out.println("第"+count+"次厚度是"+start); } //輸出統計變量。 System.out.println("要疊"+count+"次"); }} |
四、循環結構(do…while循環語句)
基本格式：
do {
循環體語句;
}while((判斷條件語句);[/code]
擴展格式：
初始化語句;
do {
循環體語句;
控制條件語句;
} while((判斷條件語句);[/code]
流程圖：
五、循環結構的區別及注意事項：
三種循環語句其實都可以完成一樣的功能，也就是說可以等價轉換，但還是有小區別的:
do…while循環至少會執行一次循環體。for循環和while循環只有在條件成立的時候才會去執行循環體
1、注意事項：
寫程序優先考慮for循環，再考慮while循環，最后考慮do…while循環。
如下代碼是死循環：
while(true){}
for(;;){}
2、循環的嵌套使用：就是循環語句的循環體本身是一個循環語句
（1）題目一：請輸出一個4行5列的星星(*)圖案：
提示：外循環控制行數，內循環控制列數
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
/* 需求：請輸出下列的形狀 * ** *** **** ***** 提示：外循環控制行數，內循環控制列數*/class ForForTest01 { public static void main(String[] args) { //通過簡單的觀察，我們看到這是一個行是5，列數是變化的形狀 //我們先打印出一個5行5列的形狀 for(int x=0; x<5; x++) { for(int y=0; y<5; y++) { System.out.print("*"); } System.out.println(); } System.out.println("--------------"); //我們實現了一個5行5列的形狀 //但是這不是我們想要的 //我們要的是列數變化的 //列數是如何變化的呢? //第一行：1列 y=0,y<=0,y++ //第二行：2列 y=0,y<=1,y++ //第三行：3列 y=0,y<=2,y++ //第四行：4列 y=0,y<=3,y++ //第五行：5列 y=0,y<=4,y++ //在看外循環x的變化，恰好就是x=0,1,2,3,4 //所以這個最終版的程序就是如下 for(int x=0; x<5; x++) { for(int y=0; y<=x; y++) { System.out.print("*"); } System.out.println(); } }} |
（2）題目二：在控制臺輸出九九乘法表：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
/* 需求：在控制臺輸出九九乘法表。 首先我們寫出九九乘法表： 1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 ... 1*9=9 2*9=18 3*9=27 ... 我們先把這個九九乘法表看出是這樣的一個形狀： * ** *** **** ***** ****** ******* ******** ********* 注意： '\x' x表示任意，這種做法叫轉移字符。 '\t' 一個制表符的位置（tabtab鍵） '\r' 回車 '\n' 換行*/class ForForTest02 { public static void main(String[] args) { for(int x=0; x<9; x++) { for(int y=0; y<=x; y++) { System.out.print("*"); } System.out.println(); } System.out.println("--------------"); //為了使用數據，我們從1開始 for(int x=1; x<=9; x++) { for(int y=1; y<=x; y++) { System.out.print(y+"*"+x+"="+y*x+"\t"); } System.out.println(); } }} |
運行效果：
六、跳轉控制語句：
前面我們已經說過了，Java中的goto是保留字，目前不能使用。雖然沒有goto語句可以增強程序的安全性，但是也帶來很多不便，比如說，我想在某個循環知道到某一步的時候就結束，現在就做不了這件事情。為了彌補這個缺陷，Java就提供了break，continue和return來實現控制語句的跳轉和中斷。
break 中斷
continue 繼續
return 返回
1、跳轉控制語句(break)：
break的使用場景：
~在選擇結構switch語句中
~在循環語句中（循環語句中加入了if判斷的情況）
注：離開使用場景的存在是沒有意義的
break的作用：
A:跳出單層循環
B:跳出多層循環
要想實現這個效果，就必須知道一個東西。帶標簽的語句。標簽名要符合Java的命名規則
格式：
標簽名: 語句
代碼舉例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
/* 控制跳轉語句： break:中斷 continue:繼續 return:返回 break:中斷的意思 使用場景： A:switch語句中 B:循環語句中。 (循環語句中加入了if判斷的情況) 注意：離開上面的兩個場景，無意義。 如何使用呢? A:跳出單層循環 B:跳出多層循環 要想實現這個效果，就必須知道一個東西。帶標簽的語句。 格式： 標簽名: 語句*/class BreakDemo { public static void main(String[] args) { //在 switch 或 loop 外部中斷 //break; //跳出單層循環 for(int x=0; x<10; x++) { if(x == 3) { break; } System.out.println("HelloWorld"); } System.out.println("over"); System.out.println("-------------"); //跳出多層循環 wc:for(int x=0; x<3; x++) { nc:for(int y=0; y<4; y++) { if(y == 2) { //break nc; break wc; } System.out.print("*"); } System.out.println(); } }} |
第38行，我們給外面的循環加了一個標簽叫wc，然后在第42行跳轉出這個標簽。
運行效果：
注：實際開發中，幾乎用不到跳轉多層循環這個功能。
2、跳轉控制語句(continue)：
continue的使用場景：
在循環語句中離開使用場景的存在是沒有意義的
continue和break的區別：
break 跳出單層循環continue 跳出一次循環，進入下一次的執行。
效果如下：
面試題：
|
1
2
3
4
5
6
7
|
for(int x=1; x<=10; x++) { if(x%3==0) { //在此處填寫代碼 } System.out.println("Java學習"); } |
在上面代碼的第4行填入一行代碼，滿足一下條件：
我想在控制臺輸出2次:"Java學習" break;
我想在控制臺輸出7次:"Java學習" continue;
我想在控制臺輸出13次:"Java學習" System.out.println("Java學習");
3、跳轉控制語句(return)
return關鍵字不是為了跳轉出循環體，更常用的功能是結束一個方法，也就是退出一個方法，跳轉到上層調用的方法。
說白了：return的作用不是結束循環，而是結束方法。
效果如下：
循環語句結合break的練習：
面試題：小芳的媽媽每天給她2.5元錢，她都會存起來，但是，每當這一天是存錢的第5天或者5的倍數的話，她都會花去6元錢，請問，經過多少天，小芳才可以存到100元錢。
代碼實現：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
/* 需求：小芳的媽媽每天給她2.5元錢，她都會存起來，但是， 每當這一天是存錢的第5天或者5的倍數的話，她都會花去6元錢， 請問，經過多少天，小芳才可以存到100元錢。 分析： A:小芳的媽媽每天給她2.5元錢 double dayMoney = 2.5; B:她都會存起來 double daySum = 0; C:從第一天開始存儲 int dayCount = 1; D:經過多少天，小芳才可以存到100元錢。 double result = 100; E:這一天是存錢的第5天或者5的倍數的話，她都會花去6元錢， 說明要判斷dayCount的值，如果對5整除就減去6元錢。 daySum -= 6; 由此還隱含了一個問題，就是如果不是5的倍數天的話，錢要累加 daySum += dayMoney; F:因為不知道是多少天，所以我用死循環，一旦超過100元我就退出循環。*/class WhileDemo { public static void main(String[] args) { //每天要存儲的錢是2.5元 double dayMoney = 2.5; //存錢的初始化值是0 double daySum = 0; //從第一天開始存儲 int dayCount = 1; //最終存儲不小于100就不存儲了 int result = 100; //因為不知道是多少天，所以我用死循環， while(true) { //累加錢 daySum += dayMoney; //一旦超過100元我就退出循環。 if(daySum >= result) { System.out.println("共花了"+dayCount+"天存儲了100元"); break; } if(dayCount%5 == 0) { //花去6元錢 daySum -= 6; System.out.println("第"+dayCount+"天花了6元錢"); } //天數變化 dayCount++; } }} |
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
原文鏈接：http://www.cnblogs.com/smyhvae/p/4150599.html
