一、循环结构：
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为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 A:求1-100之和。
4 B:求出1-100之间偶数和
5 */
6 class ForTest1 {
7 public static void main(String[] args) {
8 //求1-100之和。
9 int sum1 = 0;
10
11 for(int x=1; x<=100; x++) {
12 sum1 +=x;
13 }
14
15 System.out.println("1-100之和是："+sum1);
16 System.out.println("------------------");
17
18 //求出1-100之间偶数和
19 //方式1
20 int sum2 = 0;
21
22 for(int x=1; x<=100; x++) {
23 if(x%2 == 0) {
24 sum2 += x;
25 }
26 }
27
28 System.out.println("1-100偶数之和是："+sum2);
29 System.out.println("------------------");
30
31 //方式2
32 int sum3 = 0;
33
34 for(int x=0; x<=100; x+=2) {
35 sum3 += x;
36 }
37
38 System.out.println("1-100偶数之和是："+sum3);
39 System.out.println("------------------");
40 }
41 }
2、求5的阶乘：
1 /*
2 需求：求5的阶乘。
3
4 什么是阶乘呢?
5 n! = n*(n-1)! 规则
6 n! = n*(n-1)*(n-2)*...*3*2*1
7
8 求和思想。
9 求阶乘思想。
10 */
11 class ForTest2 {
12 public static void main(String[] args) {
13 //定义最终结果变量
14 int jc = 1;
15
16 //这里的x其实可以直接从2开始
17 //for(int x=1; x<=5; x++)
18
19 for(int x=2; x<=5; x++) {
20 jc *=x;
21 }
22
23 System.out.println("1-5的阶乘是："+jc);
24 }
25 }
3、在控制台输出所有的“水仙花数”：
1 /*
2
3 需求：在控制台输出所有的”水仙花数”
4
5 分析：
6 我们都不知道什么叫"水仙花数"，你让我怎么做呢?
7
8 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
9 举例：153就是一个水仙花数。
10 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
11
12 A:三位数其实是告诉了我们范围。
13 B:通过for循环我们就可以实现获取每一个三位数
14 但是麻烦是如何获取这个三位数的个,十,百位上的数据
15
16 我们如何获取一个数据的个,十,百呢?
17 假设有个一个数据:153
18 ge: 153%10 = 3
19 shi: 153/10%10 = 5
20 bai：153/10/10%10 = 1
21 qian：x/10/10/10%10
22 wan: x/10/10/10/10%10
23 ...
24
25 C:让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
26 如果相同，就把该数据在控制台输出。
27 */
28 class ForTest3 {
29 public static void main(String[] args) {
30 //三位数其实是告诉了我们范围。
31 for(int x=100; x<1000; x++) {
32 int ge = x%10;
33 int shi = x/10%10;
34 int bai = x/10/10%10;
35
36 //让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
37 if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
38 //如果相同，就把该数据在控制台输出。
39 System.out.println(x);
40 }
41 }
42 }
43 }
三、循环结构(while循环语句)
while循环语句格式：
while(判断条件语句) {
循环体语句;
}
//扩展格式
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
流程图：
for循环和while循环的区别：
for循环语句和while循环语句可以等价转换，但还是有些小区别的。
（1）使用区别：
控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
（2）场景区别：
- for循环适合针对一个范围判断进行操作
- while循环适合判断次数不明确操作
代码举例：
我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
1 /*
2 我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。
3 请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
4
5 分析：
6 A:定义一个统计变量，默认值是0
7 B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度
8 我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
9 C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
10 折叠一次有什么变化呢?就是厚度是以前的2倍。
11 D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
12 E:输出统计变量。
13 */
14
15 class WhileTest01 {
16 public static void main(String[] args) {
17 //定义一个统计变量，默认值是0
18 int count = 0;
19
20 //最高山峰是珠穆朗玛峰：8848m这是最终的厚度
21 //我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
22 //为了简单，我把0.01变成1，同理8848就变成了884800
23 int end = 884800;
24 int start = 1;
25
26 while(start<end) {
27 //只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
28 count++;
29
30 //折叠一次有什么变化呢?就是厚度是以前的2倍。
31 start *= 2;
32
33 System.out.println("第"+count+"次厚度是"+start);
34 }
35
36 //输出统计变量。
37 System.out.println("要叠"+count+"次");
38 }
39 }
四、循环结构(do…while循环语句)
基本格式：
do {
循环体语句;
}while((判断条件语句);
扩展格式：
初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);
流程图：
五、循环结构的区别及注意事项：
三种循环语句其实都可以完成一样的功能，也就是说可以等价转换，但还是有小区别的:
- 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 class ForForTest01 {
12 public static void main(String[] args) {
13 //通过简单的观察，我们看到这是一个行是5，列数是变化的形状
14 //我们先打印出一个5行5列的形状
15 for(int x=0; x<5; x++) {
16 for(int y=0; y<5; y++) {
17 System.out.print("*");
18 }
19 System.out.println();
20 }
21
22 System.out.println("--------------");
23
24 //我们实现了一个5行5列的形状
25 //但是这不是我们想要的
26 //我们要的是列数变化的
27 //列数是如何变化的呢?
28 //第一行：1列 y=0,y<=0,y++
29 //第二行：2列 y=0,y<=1,y++
30 //第三行：3列 y=0,y<=2,y++
31 //第四行：4列 y=0,y<=3,y++
32 //第五行：5列 y=0,y<=4,y++
33 //在看外循环x的变化，恰好就是x=0,1,2,3,4
34 //所以这个最终版的程序就是如下
35 for(int x=0; x<5; x++) {
36 for(int y=0; y<=x; y++) {
37 System.out.print("*");
38 }
39 System.out.println();
40 }
41 }
42 }
（2）题目二：在控制台输出九九乘法表：
1 /*
2 需求：在控制台输出九九乘法表。
3
4 首先我们写出九九乘法表：
5 1*1=1
6 1*2=2 2*2=4
7 1*3=3 2*3=6 3*3=9
8 1*4=4 2*4=8 3*4=12 4*4=16
9 ...
10 1*9=9 2*9=18 3*9=27 ...
11
12 我们先把这个九九乘法表看出是这样的一个形状：
13 *
14 **
15 ***
16 ****
17 *****
18 ******
19 *******
20 ********
21 *********
22
23 注意：
24 '\x' x表示任意，这种做法叫转移字符。
25
26 '\t' 一个制表符的位置（tabtab键）
27 '\r' 回车
28 '\n' 换行
29 */
30 class ForForTest02 {
31 public static void main(String[] args) {
32 for(int x=0; x<9; x++) {
33 for(int y=0; y<=x; y++) {
34 System.out.print("*");
35 }
36 System.out.println();
37 }
38 System.out.println("--------------");
39 //为了使用数据，我们从1开始
40 for(int x=1; x<=9; x++) {
41 for(int y=1; y<=x; y++) {
42 System.out.print(y+"*"+x+"="+y*x+"\t");
43 }
44 System.out.println();
45 }
46 }
47 }
运行效果：
六、跳转控制语句：
前面我们已经说过了，Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便，比如说，我想在某个循环知道到某一步的时候就结束，现在就做不了这件事情。为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。
- break 中断
- continue 继续
- return 返回
1、跳转控制语句(break)：
break的使用场景：
- 在选择结构switch语句中
- 在循环语句中（循环语句中加入了if判断的情况）
注：离开使用场景的存在是没有意义的
break的作用：
A:跳出单层循环
B:跳出多层循环
要想实现这个效果，就必须知道一个东西。带标签的语句。标签名要符合Java的命名规则
格式：
标签名: 语句
代码举例：
1 /*
2 控制跳转语句：
3 break:中断
4 continue:继续
5 return:返回
6
7 break:中断的意思
8 使用场景：
9 A:switch语句中
10 B:循环语句中。
11 (循环语句中加入了if判断的情况)
12 注意：离开上面的两个场景，无意义。
13
14 如何使用呢?
15 A:跳出单层循环
16 B:跳出多层循环
17 要想实现这个效果，就必须知道一个东西。带标签的语句。
18 格式：
19 标签名: 语句
20 */
21 class BreakDemo {
22 public static void main(String[] args) {
23 //在 switch 或 loop 外部中断
24 //break;
25
26 //跳出单层循环
27 for(int x=0; x<10; x++) {
28 if(x == 3) {
29 break;
30 }
31 System.out.println("HelloWorld");
32 }
33
34 System.out.println("over");
35 System.out.println("-------------");
36
37 //跳出多层循环
38 wc:for(int x=0; x<3; x++) {
39 nc:for(int y=0; y<4; y++) {
40 if(y == 2) {
41 //break nc;
42 break wc;
43 }
44 System.out.print("*");
45 }
46 System.out.println();
47 }
48 }
49 }
第38行，我们给外面的循环加了一个标签叫wc，然后在第42行跳转出这个标签。
运行效果：
注：实际开发中，几乎用不到跳转多层循环这个功能。
2、跳转控制语句(continue)：
continue的使用场景：
- 在循环语句中
- 离开使用场景的存在是没有意义的
continue和break的区别：
- break 跳出单层循环
- continue 跳出一次循环，进入下一次的执行。
效果如下：
面试题：
1 for(int x=1; x<=10; x++) {
2 if(x%3==0) {
3 //在此处填写代码
4
5 }
6 System.out.println("Java学习");
7 }
在上面代码的第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 需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，
3 每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
4 请问，经过多少天，小芳才可以存到100元钱。
5
6 分析：
7 A:小芳的妈妈每天给她2.5元钱
8 double dayMoney = 2.5;
9 B:她都会存起来
10 double daySum = 0;
11 C:从第一天开始存储
12 int dayCount = 1;
13 D:经过多少天，小芳才可以存到100元钱。
14 double result = 100;
15 E:这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
16 说明要判断dayCount的值，如果对5整除就减去6元钱。
17 daySum -= 6;
18 由此还隐含了一个问题，就是如果不是5的倍数天的话，钱要累加
19 daySum += dayMoney;
20 F:因为不知道是多少天，所以我用死循环，一旦超过100元我就退出循环。
21 */
22 class WhileDemo {
23 public static void main(String[] args) {
24 //每天要存储的钱是2.5元
25 double dayMoney = 2.5;
26
27 //存钱的初始化值是0
28 double daySum = 0;
29
30 //从第一天开始存储
31 int dayCount = 1;
32
33 //最终存储不小于100就不存储了
34 int result = 100;
35
36 //因为不知道是多少天，所以我用死循环，
37 while(true) {
38 //累加钱
39 daySum += dayMoney;
40
41 //一旦超过100元我就退出循环。
42 if(daySum >= result) {
43 System.out.println("共花了"+dayCount+"天存储了100元");
44 break;
45 }
46
47 if(dayCount%5 == 0) {
48 //花去6元钱
49 daySum -= 6;
50 System.out.println("第"+dayCount+"天花了6元钱");
51 }
52
53 //天数变化
54 dayCount++;
55 }
56 }
57 }
