Java语法基础（四）----循环结构语句

控制条件语句：这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。

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;

11 for(int x=1; x =100; x++) {

12 sum1 +=x;

15 System.out.println("1-100之和是："+sum1);

16 System.out.println("------------------");

18 //求出1-100之间偶数和

19 //方式1

20 int sum2 = 0;

22 for(int x=1; x =100; x++) {

23 if(x%2 == 0) {

24 sum2 += x;

28 System.out.println("1-100偶数之和是："+sum2);

29 System.out.println("------------------");

31 //方式2

32 int sum3 = 0;

34 for(int x=0; x =100; x+=2) {

35 sum3 += x;

38 System.out.println("1-100偶数之和是："+sum3);

39 System.out.println("------------------");

41 }

2、求5的阶乘：

 1 /*

 2 需求：求5的阶乘。

 4 什么是阶乘呢?

 5 n! = n*(n-1)! 规则

 6 n! = n*(n-1)*(n-2)*...*3*2*1

 8 求和思想。

 9 求阶乘思想。

10 */

11 class ForTest2 {

12 public static void main(String[] args) {

13 //定义最终结果变量

14 int jc = 1;

16 //这里的x其实可以直接从2开始

17 //for(int x=1; x x++) 

19 for(int x=2; x =5; x++) {

20 jc *=x;

23 System.out.println("1-5的阶乘是："+jc);

25 }

3、在控制台输出所有的“水仙花数”：

 1 /*

 3 需求：在控制台输出所有的”水仙花数”

 5 分析：

 6 我们都不知道什么叫"水仙花数"，你让我怎么做呢?

 8 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。

 9 举例：153就是一个水仙花数。

10 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153

12 A:三位数其实是告诉了我们范围。

13 B:通过for循环我们就可以实现获取每一个三位数

14 但是麻烦是如何获取这个三位数的个,十,百位上的数据

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 ...

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;

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);

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 请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?

 5 分析：

 6 A:定义一个统计变量，默认值是0

 7 B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度

 8 我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度

 9 C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?

10 折叠一次有什么变化呢?就是厚度是以前的2倍。

11 D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++

12 E:输出统计变量。

13 */

15 class WhileTest01 {

16 public static void main(String[] args) {

17 //定义一个统计变量，默认值是0

18 int count = 0;

20 //最高山峰是珠穆朗玛峰：8848m这是最终的厚度

21 //我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度

22 //为了简单，我把0.01变成1，同理8848就变成了884800

23 int end = 884800;

24 int start = 1;

26 while(start end) {

27 //只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++

28 count++;

30 //折叠一次有什么变化呢?就是厚度是以前的2倍。

31 start *= 2;

33 System.out.println("第"+count+"次厚度是"+start);

36 //输出统计变量。

37 System.out.println("要叠"+count+"次");

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 需求：请输出下列的形状

 4 **

 5 ***

 6 ****

 7 *****

 9 提示：外循环控制行数，内循环控制列数

10 */

11 class ForForTest01 {

12 public static void main(String[] args) {

13 //通过简单的观察，我们看到这是一个行是5，列数是变化的形状

14 //我们先打印出一个5行5列的形状

15 for(int x=0; x x++) {

16 for(int y=0; y y++) {

17 System.out.print("*");

19 System.out.println();

22 System.out.println("--------------");

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 x++) {

36 for(int y=0; y y++) {

37 System.out.print("*");

39 System.out.println();

42 }

（2）题目二：在控制台输出九九乘法表：

 1 /*

 2 需求：在控制台输出九九乘法表。

 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 ...

12 我们先把这个九九乘法表看出是这样的一个形状：

14 **

15 ***

16 ****

17 *****

18 ******

19 *******

20 ********

21 *********

23 注意：

24 \x x表示任意，这种做法叫转移字符。

26 \t 一个制表符的位置（tabtab键）

27 \r 回车

28 \n 换行

29 */

30 class ForForTest02 {

31 public static void main(String[] args) {

32 for(int x=0; x x++) {

33 for(int y=0; y y++) {

34 System.out.print("*");

36 System.out.println();

38 System.out.println("--------------");

39 //为了使用数据，我们从1开始

40 for(int x=1; x x++) {

41 for(int y=1; y y++) {

42 System.out.print(y+"*"+x+"="+y*x+"\t");

44 System.out.println();

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:返回

 7 break:中断的意思

 8 使用场景：

 9 A:switch语句中

10 B:循环语句中。

11 (循环语句中加入了if判断的情况)

12 注意：离开上面的两个场景，无意义。

14 如何使用呢?

15 A:跳出单层循环

16 B:跳出多层循环

17 要想实现这个效果，就必须知道一个东西。带标签的语句。

18 格式：

19 标签名: 语句

20 */

21 class BreakDemo {

22 public static void main(String[] args) {

23 //在 switch 或 loop 外部中断

24 //break;

26 //跳出单层循环

27 for(int x=0; x x++) {

28 if(x == 3) {

29 break;

31 System.out.println("HelloWorld");

34 System.out.println("over");

35 System.out.println("-------------");

37 //跳出多层循环

38 wc:for(int x=0; x x++) {

39 nc:for(int y=0; y y++) {

40 if(y == 2) {

41 //break nc;

42 break wc;

44 System.out.print("*");

46 System.out.println();

49 }

第38行，我们给外面的循环加了一个标签叫wc，然后在第42行跳转出这个标签。

运行效果：

注：实际开发中，几乎用不到跳转多层循环这个功能。

 

2、跳转控制语句(continue)：

continue的使用场景：

在循环语句中 离开使用场景的存在是没有意义的

continue和break的区别：

break  跳出单层循环 continue  跳出一次循环，进入下一次的执行。

效果如下：

面试题：

1 for(int x=1; x x++) {

2 if(x%3==0) {

3 //在此处填写代码

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元钱。

 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;

27 //存钱的初始化值是0

28 double daySum = 0;

30 //从第一天开始存储

31 int dayCount = 1;

33 //最终存储不小于100就不存储了

34 int result = 100;

36 //因为不知道是多少天，所以我用死循环，

37 while(true) {

38 //累加钱

39 daySum += dayMoney;

41 //一旦超过100元我就退出循环。

42 if(daySum = result) {

43 System.out.println("共花了"+dayCount+"天存储了100元");

44 break;

47 if(dayCount%5 == 0) {

48 //花去6元钱

49 daySum -= 6;

50 System.out.println("第"+dayCount+"天花了6元钱");

53 //天数变化

54 dayCount++;

57 }

 

 

java三种循环（for、while、do while）和终止语句（break、continue、return） for循环一般在明确循环条件和循环次数时使用。（常用） while（while先判断再执行，不通过则不执行）循环和do...while（至少先执行一次后再进行判断）循环在不明确循环次数时使用。
生命壹号 个人网站：smyhvae.com。博客园：cnblogs.com/smyhvae。微信公众号：生命团队 | vitateam