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

一、循环结构：

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为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之间偶数和：

 /*
     需求：
         A:求1-100之和。
         B:求出1-100之间偶数和
 */
 class ForTest1 {
     public static void main(String[] args) {
         //求1-100之和。
         int sum1 = ;

         for(int x=; x<=; x++) {
             sum1 +=x;
         }

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

         //求出1-100之间偶数和
         //方式1
         int sum2 = ;

         for(int x=; x<=; x++) {
             if(x% == ) {
                 sum2 += x;
             }
         }

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

         //方式2
         int sum3 = ;

         for(int x=; x<=; x+=) {
                 sum3 += x;
         }

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

2、求5的阶乘：

 /*
     需求：求5的阶乘。

     什么是阶乘呢?
         n! = n*(n-1)! 规则
         n! = n*(n-1)*(n-2)*...*3*2*1

     求和思想。
     求阶乘思想。
 */
 class ForTest2 {
     public static void main(String[] args) {
         //定义最终结果变量
         int jc = ;

         //这里的x其实可以直接从2开始
         //for(int x=1; x<=5; x++) 

         for(int x=; x<=; x++) {
             jc *=x;
         }

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

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

 /*

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

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

         所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
         举例：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=; x<; x++) {
             int ge = x%;
             int shi = x/%;
             int bai = x//%;

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

 /*
     我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。
     请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?

     分析：
         A:定义一个统计变量，默认值是0
         B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度
           我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
         C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
           折叠一次有什么变化呢?就是厚度是以前的2倍。
         D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
         E:输出统计变量。
 */

 class WhileTest01 {
     public static void main(String[] args) {
         //定义一个统计变量，默认值是0
         int count = ;

         //最高山峰是珠穆朗玛峰：8848m这是最终的厚度
         //我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
         //为了简单，我把0.01变成1，同理8848就变成了884800
         int end = ;
         int start = ;

         while(start<end) {
             //只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
             count++;

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

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

         //输出统计变量。
         System.out.println("要叠"+count+"次");
     }
 }

四、循环结构(do…while循环语句)

基本格式：

   do {
         循环体语句;
   }while((判断条件语句);

扩展格式：

   初始化语句;
   do {
         循环体语句;
         控制条件语句;
    } while((判断条件语句);

流程图：

 

五、循环结构的区别及注意事项：

三种循环语句其实都可以完成一样的功能，也就是说可以等价转换，但还是有小区别的:

• do…while循环至少会执行一次循环体。
• for循环和while循环只有在条件成立的时候才会去执行循环体

1、注意事项：

写程序优先考虑for循环，再考虑while循环，最后考虑do…while循环。

如下代码是死循环：

• while(true){}
• for(;;){}

2、循环的嵌套使用：就是循环语句的循环体本身是一个循环语句

（1）题目一：请输出一个4行5列的星星(*)图案：

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

 /*
     需求：请输出下列的形状
         *
         **
         ***
         ****
         *****

         提示：外循环控制行数，内循环控制列数
 */
 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*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的命名规则

格式：

标签名: 语句

代码举例：

 /*
     控制跳转语句：
         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  跳出一次循环，进入下一次的执行。

效果如下：

面试题：

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

代码实现：

 /*
     需求：小芳的妈妈每天给她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++;
         }
     }
 }

 


我的公众号

想学习代码之外的软技能？不妨关注我的微信公众号：生命团队（id：vitateam）。

扫一扫，你将发现另一个全新的世界，而这将是一场美丽的意外：