Java 循环语句

文章目录

Java 循环语句
- 一，for 循环
- - 1. for 循环结构
  - 2. for 循环案例: 输出5行HelloWord
  - 3. for 循环案例: 写出输出的结果 (格式多样性)
  - 4. for 循环案例: 遍历100以内的偶数。并获取偶数的个数，获取所有的偶数的和
  - 5. for 循环案例: 输出所有的水仙花数
  - 6. for 循环案例: 输入两个正整数 m 和 n，求其最大公约数和最小公倍数
  - 7. for 循环案例: ATM取款
- 二，while 循环
- - 1. while 循环结构
  - 2. while 循环案例：遍历100以内的偶数。并获取偶数的个数，获取所有的偶数的和
  - 3. while 循环案例：随机生成一个100以内的数，猜这个随机数是多少
  - 4. while 循环案例: 折纸珠穆朗玛峰
  - 5. while 循环案例: ATM取款
- 三，do-while 循环
- - 1. do-while 循环结构
  - 2. do-while 循环案例:遍历100以内的偶数，并且输出偶数的个数和总和
  - 3. do-while 循环案例: ATM取款
- 四，无限循环
- - 需求:从键盘输入不确定的整数，并判断读入的整数和负数的个数，输入为0时结束程序

Java 循环语句

理解：循环语句具有在某些条件满足的情况下，反复执行特定代码的功能
循环结构分类：

for 循环
while 循环
do - while 循环
循环结构四要素：
初始化部分
循环条件部分
循环体部分
迭代部分

一，for 循环

1. for 循环结构

循环测试
1). Java 中规范了3种循环结构：for, while , do-while
2). 凡是循环结构，就一定会有4个要素:
① 初始化条件
② 循环条件 --> 一定是 boolen 类型的变量或者表达式
③ 循环体
④ 迭代部分
3). for 循环的格式
for(①;②;④){
③
}

执行过程: ① - ② - ③ - ④ - ② - ③ - ④ … ② - ③ - ④ 初始化部分只走一次，后面都是不重复的
说明：

我们可以在循环结构中使用break。一旦执行break，就跳出（或结束）当前循环结构。
如何结束一个循环结构?
方式1：循环条件不满足。（即循环条件执行完以后是false）
方式2：在循环体中执行了break

2. for 循环案例: 输出5行HelloWord

设置初始化变量
设置循环条件
输出循环体内容
设置迭代部分
然后重复 2,3,4部分直到不满足循环条件跳出for 循环

 for(int i=1;i<=5;i++){
                  System.out.println("HelloWord");
            }

输出结果:
在这里插入图片描述

3. for 循环案例: 写出输出的结果 (格式多样性)

这个主要是查看 for 循环格式的多样性，来看for 循环的流程
先是初始化部分，输出了一个a,然后到第二部分循环条件，num 值为1,小于3然后到循环体部分，输出b,然后到迭代部分先输出一个c，然后num + 1 现在num变成2了，再进去循环体输出b，然后再到迭代部分，输出一个c，num + 1，现在 num 变成3了，不满足循环条件，跳出 for 循环。所以输出的结果是
a,b,c,b,c

int num = 1;
for(System.out.print("a");num < 3;System.out.print("c"),num++){
                  System.out.print("b");
            }

输出结果
在这里插入图片描述

4. for 循环案例: 遍历100以内的偶数。并获取偶数的个数，获取所有的偶数的和

这个主要是看 for 循环的累加思想
我们先看 for 循环体内，首先是要遍历出 100 以内的偶数，因为是要偶数，而且知道范围是在 100 以内，那我们初始值直接设置为2，然后循环条件设置为小于等于 100，然后i += 2，因为是要偶数，我们的初始值是2，然后每次加2那么每次都是偶数了，然后把 i 输出出来就行了，每次都是输出的偶数，然后我们开始解决第二个问题，记录个数和偶数的和，我们得定义两个变量来接，一个 count 变量，一个 sums 变量，每次 count + 1就可以了，输出偶数的时候，每输出一次，count 就 + 1了，当for 循环结束的时候，循环了多少次，count 就记录了多少次也就是偶数的个数了，sums 就是每次输出的偶数的值加起来就行，sums += i , i 就是输出的每次的偶数的值，循环了50次每次都把之前的和给加起来。

			int count = 0; //这个是 记录偶数的个数
            int sums = 0;  // 这个是记录偶数的和
            for(int i=2;i<=100;i+=2){
                  System.out.print(i);
                  count += 1;
                  sums += i;
            }
            System.out.println("偶数个数:" + count + "偶数的和:" + sums);

结果输出：这里太长了我们就不全部截了，最后结果 100 以内偶数 50 个，100以内偶数的和 2550
在这里插入图片描述

5. for 循环案例: 输出所有的水仙花数

所谓水仙花数是指一个3位数，其各各位上数字立方和等于其本身
例如：153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3
我们结合分支结构使用
解题思路：首先水仙花数是三位数，所以设置循环初始值为 100 ，然后循环条件 i < 1000，然后我们得想办法把这个三位数的每一位数给取出来，百位直接除以一个 100 就能得到百位上的数，比如 300 / 100 = 3，然后十位先除以一个 10 再取余 10 ，比如 310 / 10 % 10 = 1 我们先除以10等于31，然后31对10取余结果就是1，然后我们取各位上的数，直接对10取余，比如 31 % 10 结果就为 1，这样我们各个位置上的数都取到了，接下来 if 判断，如果这三个位的各自的立方，加起来的总数等于这个数，那么就是水仙花数，例如 153 = 1 * 1 *1 + 5 * 5 * 5 + 3 * 3 * 3

for(int i=100;i<1000;i++){
                  // 针对每一个 三位数i ,获取其各个位数上面的值
                 int baiwei = i / 100 ; //获得百位上的数
                 int shiwei = i / 10 % 10; // 获取十位上的数
                 int gewei = i % 10;   // 获取个位上的数

                 // 判断是否满足水仙花数的规则
                if((baiwei * baiwei * baiwei) + (shiwei * shiwei * shiwei) + (gewei * gewei * gewei)==i){
                  System.out.println(i);
                }
            }

输出结果
在这里插入图片描述

6. for 循环案例: 输入两个正整数 m 和 n，求其最大公约数和最小公倍数

比如 12 和 24 的最大公约数是 4，最小公倍数是 60
约数：12 为例，约数有 1,2,3,4,6,12
20 为例：约数有1,2,4,5,10.20
思路我们先求最大公约数:
我们这里需要定义两个数，然后 for 循环开始，我们这里初始值是从1开始，因为他们的公约数都是从1开始的，然后，循环条件设置为小于等于这两个数里面较小的那一个，然后 i++ ，下面是循环体内，我们判断一下，如果这两个数分别除以那个数都能够整数，说明这就是他们的公约数，然后这里的输出的结果是从小到大的，比如他们除以1的时候都能够整数，除以2的时候也能够被整除，那么我们定义一个空的列表，把这些公约数都放进列表里，然后对这个列表里的数进行排序，取最大的一个，这里我们是直接用的取最大值，Collections.max(num) 方法，数组里取最大值,最大公约数取完了

			int n1 = 12;
            int n2 =20;

            //获取n1和n2中的较小值
            int min = (n1 < n2)? n1:n2;

            List<Integer> num = new ArrayList<Integer>(); //用来装他们的最大公约数
            for(int i=1;i<=min;i++){
                  if(n1 % i  == 0 && n2 % i == 0){
                        num.add(i);
                  }
            }
           Integer maxs = Collections.max(num); // 获取list 列表中的最大数
           System.out.println("他们的最大公约数为:" + maxs); // 获取到 他们的最大公约数

接下来取最小公倍数：
倍数：12为例，倍数有12,24,36,48,60,72…
20为例，倍数有20,40,60,80…
也就是能够整数他们的数
思路：能够同时整数他们两个，说明至少也得是他们这两个数里最大的那个。获取n1和n2中的较大值，然后我们for 循环里的内容，首先初始值，设置为他们里最大的那个数，用了一个 max 变量去接，然后循环条件，i >= 1 因为他们的公倍数是无穷的，然后迭代 i++，然后我们循环里 if 判断，能够同时除以他们的数那么就输出，因为我们要的是最小的公倍数，所以第一个公倍数出来的时候，我们就可以中止循环了，加上了一个break。

 int max = (n1 > n2)? n1:n2;
            for(int i=max;i>=1;i++){
                  if(i%n1 == 0 && i%n2==0){
                        System.out.println("他们的最小公倍数为："+i);
                        break;
                  }
            }

结果输出;
在这里插入图片描述

7. for 循环案例: ATM取款

声明变量balance并初始化为0，用以表示银行账户的余额，下面通过ATM机程序实现存款，取款等功能。
===========ATM===========
1.存款
2.取款
3.显示余额
4.退出
请选择(1-4):
实现思路：我们首先需求是要求有4个功能，第一个是能存款，第二个是能够取款，第三个是显示余额，第四个是退出程序，我们要去存款，肯定的从键盘输入数值，所以第一步的设置一个从键盘输入的数值的变量用来存钱的初始值，然后第二步我们进入循环里，首先是循环初始值，我们设置一个boolen类型的变量tuichu2来控制循环一直运行，然后循环条件就是这个变量本身，也就是为true的时候循环，然后上面的界面的内容我们得打印出来，然后用于要选择功能，所以我们要再设置一个从键盘输入的变量，来控制用户输入的选项，接下来就是 if 判断，用户输入什么数字对应进入什么功能，进入1是存款，是输入存款的金额，那我们设置个变量来存这个值，然后赋值给 balanceue, balanceue += money3; 因为他是我们设置的存钱的初始值，然后第二个是取款，我们同样的设置一个变量来接收取款的金额，然后 balanceue -= money4; 一样的逻辑，然后4就是退出了，这个时候我们让循环条件 tuichu2 = false 跳出循环。

// for循环实现
             Scanner scan = new Scanner(System.in);
             double balanceue = scan.nextDouble(); //定义变量，来记录银行余额
             for(boolean tuichu2 = true;tuichu2;){
                  System.out.println("===========ATM=========");
                  System.out.println("请选择1-4");
                  System.out.println("1.存款");
                  System.out.println("2.取款");
                  System.out.println("3.显示余额");
                  System.out.println("4.退出");
                  int xuanze2 = scan.nextInt(); //用来控制用户输入选项
                  if(xuanze2 == 1){
                        System.out.println("输入你的存款数:");
                        double money3 = scan.nextDouble();
                        balanceue += money3;
                  }else if(xuanze2 == 2) {
                        System.out.println("输入你的取款金额:");
                        double money4 = scan.nextDouble();
                        balanceue -= money4;
                  }else if(xuanze2 == 3) {
                        System.out.println("你的余额为：" + balanceue);
                  }else if(xuanze2 == 4){
                        System.out.println("退出程序");
                        tuichu2 = false;
                  }
             }

结果输出:
在这里插入图片描述

二，while 循环

1. while 循环结构

Java 中规范了3种循环结构：for, while , do-while
凡是循环结构，就一定会有4个要素:
① 初始化条件
② 循环条件 --> 一定是 boolen 类型的变量或者表达式
③ 循环体
④ 迭代部分
while 的格式
①
while(②)
③
④
执行过程：① - ② -③ - ④ - ② - ③ - ④ - … - ② (和for循环过程是一样的)
for循环和while 循环可以相互转换
for循环和while循环的小区别：初始化条件的作用域范围不同，while循环中的初始化条件在while循环结束后，依然有效

2. while 循环案例：遍历100以内的偶数。并获取偶数的个数，获取所有的偶数的和

我们将这个案例，用 while 循环再实现一下
思路：while 循环和 for循环的不同点，他的初始值是在循环体外面，我们设置一个变量值为2，因为是求偶数，然后循环条件，num2 <= 100，因为是100以内的，然后是循环体，每次 num2 += 2，
这样知道不满足 num2<=100 的时候，跳出循环，我们把所有的偶数得到了，然后要记录个数，还有偶数的和，还是一样的设置两个变量来接，每循环一次，counts++，记录个数，然后sums += num2，进行累加，然后都得到了，我这里是把所有的偶数放在列表里去了，这样比较好看。

 //需求2：遍历1-100以内的偶数，并获取偶数的个数，并且并获取偶数的个数，获取所有的偶数的和
            int num2 = 2; //这是初始值
            int count = 0; //定义一个变量记录个数
            int sums = 0; //定义一个变量接收总和
            ArrayList<Integer> arrayList = new ArrayList<Integer>();
            while (num2 <= 100) {
                  sums += num2;
                  arrayList.add(num2);
                  num2 += 2;
                  count++;
            }
            System.out.println("100以内的偶数:" + arrayList);
            System.out.println("100以内的偶数有:" + count + "个" + "总和为：" + sums);

3. while 循环案例：随机生成一个100以内的数，猜这个随机数是多少

规则：从键盘输入数，如果大了，提示大了，如果小了，提示小了，如果对了，就不在猜了，并统计一共猜了多少次。
提示：生成一个[a,b] 范围的随机数的方式：(int)(Math.ranom() * (b - a + 1) + a)
思路：首先我们用 Math.random()方法生成一个随机数，这个方法生成的数是[0,1]的随机的double值，所以我们得乘上一个100，这样生成的就是0到100的随机数了，这个是一个double数，我们在前面加上(int)强制转换为 int 类型，然后我们从键盘输入一个0-100的数，然后我们开始写while循环，我们的初始值就是键盘输入的值，然后循环条件是，这两个数不想当，当他们等于的时候，就跳出循环了，if 判断如果输入的数大于随机生成的数，那么提升输入的数大了，如果输入的数小于随机生成的数，那么提示输入的数小了，然后我们在判断条件外，重新从键盘中输入一个数，然后再次判断，直到他们相等，跳出循环，我们也是定义一个变量counts，来记录猜的次数，每猜一次，counts++，这道题就完成了。

//1. 生成一个[1,100]范围内的随机整数
             int target = (int)(Math.random() * 100) + 1; //在前面加上(int)是强转为 int 类型，获取一个大于等于0.0且小于1.0的伪随机double值所以乘上一个100
             //2. 使用Scanner，从键盘获取数据
             //3. 使用循环结构，进行多次循环的对比和获取数据
            Scanner input= new Scanner(System.in); //从键盘获取数据
            System.out.println("请输入0-100的整数:");
            int shuchu = input.nextInt();
            int counts = 1; // 记录猜了多少次
            while (shuchu != target) {
                  if(shuchu > target){
                        System.out.println("输入的数大了");
                  }else if (shuchu < target) {
                        System.out.println("输入的数小了");
                  }
                  System.out.println("请输入0-100的整数:");
                  shuchu = input.nextInt();
                  counts++;
            }
            System.out.println("恭喜你，猜对了");
           System.out.println("猜了" + counts + "次" );

结果输出：
在这里插入图片描述

4. while 循环案例: 折纸珠穆朗玛峰

世界最高山峰是珠穆朗玛峰，它的高度是8848.86米，假如我有一张足够大的纸，它的厚度是0.1毫米，请问我折叠多少次，可以折叠成珠穆朗玛峰的高度?
1 米等于 1000 毫米，8848.86米 = 8848860 毫米
思路：就是每次 * 2 就行了，循环，直到大于等于 8848.86 跳出循环 ,这是指数级的增长，0.1的初始值，折叠27次就到珠峰高度了。

			double paper = 0.1; //单位：毫米
            int countss = 0; // 记录折的次数
            while (paper <= 8848860) {
                  paper *= 2;
                  countss++;
            }
            System.out.println("折叠了" + countss + "次" + "到达了珠峰的高度");

结果输出;
在这里插入图片描述

5. while 循环案例: ATM取款

声明变量balance并初始化为0，用以表示银行账户的余额，下面通过ATM机程序实现存款，取款等功能。
===========ATM===========
1.存款
2.取款
3.显示余额
4.退出
请选择(1-4):

 //定义balance变量，用来记录银行余额
             double balance = 0;
             Scanner input = new Scanner(System.in);
             boolean tuichu = true;  //用来控制退出
            //  //生成ATM取款的界面（这部分会反复出现，放在循环里）
             while (tuichu) {
                  System.out.println("===========ATM=========");
                  System.out.println("请选择1-4");
                  System.out.println("1.存款");
                  System.out.println("2.取款");
                  System.out.println("3.显示余额");
                  System.out.println("4.退出");
                  int xuanze = input.nextInt();
                  if(xuanze == 1){
                        System.out.println("请输入存款的余额");
                        double money1 = input.nextDouble();
                        if(money1 > 0){
                              balance += money1;
                        }
                  }else if(xuanze == 2){
                        System.out.println("请输入取款金额");
                        double money2 = input.nextDouble();
                        balance -= money2;
                  }else if(xuanze == 3){
                        System.err.println("余额为：" + balance);
                  }else if (xuanze == 4) {
                        System.out.println("退出程序");
                        tuichu = false;
                  }else{
                        System.out.println("输入有误,重新输入");
                  }
             }

三，do-while 循环

1. do-while 循环结构

循环测试 - do-while

Java 中规范了3种循环结构：for, while , do-while
凡是循环结构，就一定会有4个要素:
① 初始化条件
② 循环条件 --> 一定是 boolen 类型的变量或者表达式
③ 循环体
④ 迭代部分
do-while 的格式
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分)
执行过程：① - ③ -④ - ② - ③ -④ - ② - ③ - ④ … - ②
5.说明：
do-while 循环至少会执行一次循环体
for循环，while循环，do-while循环,三者之间是可以相互转换的
do-while循环结构，在开发中，相较于for,while循环来讲，使用的比较少

2. do-while 循环案例:遍历100以内的偶数，并且输出偶数的个数和总和

 //遍历100以内的偶数，并且输出偶数的个数和总和
            int num = 2;
            int count = 0; //记录偶数个数
            int sum = 0;//记录偶数总和
            do{
                  System.out.println(num);
                  num += 2;
                  count++;
                  sum += num;

            }while(num <= 100);

            System.out.println("偶数个数有：" + count + "个" + "偶数总和为" + sum);

3. do-while 循环案例: ATM取款

//do-while 实现
Scanner scan = new Scanner(System.in);
boolean tuichu = true;
double qian = scan.nextDouble();

        do{
              System.out.println("===========ATM=========");
                     System.out.println("请选择1-4");
                     System.out.println("1.存款");
                     System.out.println("2.取款");
                     System.out.println("3.显示余额");
                     System.out.println("4.退出");
              int xuanze = scan.nextInt();
              if (xuanze == 1) {
                    double cunkuan = scan.nextDouble();
                    if(cunkuan > 0){ 
                          qian += cunkuan;   
                    }
              }else if(xuanze == 2){
                    double qukuan = scan.nextDouble();
                    if (qukuan > 0) {
                          qian -= qukuan;
                    }
              }else if(xuanze == 3){
                    System.out.println("您的余额为:" + qian);
              }else if(xuanze == 4){
                    System.out.println("退出程序");
                    tuichu = false;
              }
        }while(tuichu);

结果输出：
在这里插入图片描述

四，无限循环

"无限"循环结构的使用
格式：while(true) 或 for(;`;)

需求:从键盘输入不确定的整数，并判断读入的整数和负数的个数，输入为0时结束程序

思路: 像这种不确定循环次数，就称之为无限循环，在触发某个条件的时候结束循环，一定要有结束条件，不然就成死循环了，像这种不知道具体循环次数和范围的，用 while 循环来做会比较美观。
当输入的数等于2的时候用berak结束循环。

Scanner scan = new Scanner(System.in);
         int count1 = 0; // 记录正数个数
         int count2 = 0; // 记录负数个数
         while (true) {
            int zhengshu = scan.nextInt();
            if(zhengshu != 0){
               if(zhengshu > 0){
                  count1++;
               }else if(zhengshu < 0){
                  count2++;
               }
            }else if(zhengshu == 0){
               break;
            }
         }
         System.out.println("您输入的整数个数:" + count1);
         System.out.println("您输入负数的个数：" + count2);