• 006-JavaSE基础巩固练习：while循环结构的练习

    一、while循环结构的练习

    1、打印纸张的次数

    • 需求：

      • 世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)
      • 假如我有一张足够大的纸，它的厚度是0.1毫米。
      • 请问，我需要折叠多少次，才可以折成珠穆朗玛峰的高度？

    • 实现：

      package com.app.demo8_while_practice;

/**
    while循环结构的练习
        打印纸张折叠的次数：
            世界最高山峰是珠穆朗玛峰(8844.43米=8844400毫米)
            我有一张足够大的纸，它的厚度是0.1毫米
            请问，我需要折叠多少次，才可以将纸张折叠成珠穆朗玛峰的高度？
 */
public class WhileDemo1 {
    public static void main(String[] args) {
        // 1、定义变量，用于存储珠穆朗玛峰的高度
        double peakHeight = 8844400;

        // 2、定义变量，用于存储纸张的厚度
        double paperHeight = 0.1;

        // 3、调用纸张折叠的方法，需要返回纸张折叠的次数
        int count = paperFold(peakHeight, paperHeight);

        // 5、判断返回的结果是否为 -1
        if (count == -1) {
            // a、为 -1: 说明传入的参数不是正数
            System.out.println("数据必须为正数~");
        }else {
            // b、不为 -1: 说明纸张折叠高度达到了山峰的高度，输出纸张折叠的次数
            System.out.println("纸张需要折叠" + count + "次，才可以折成珠穆朗玛峰的高度！");
        }
    }

    /**
     * 4、定义纸张折叠的实现方法
     * @param peakHeight        山峰的高度
     * @param paperHeight       纸张的厚度
     * @return              返回纸张折叠的次数
     */
    private static int paperFold(double peakHeight, double paperHeight) {
        // a、山峰的高度和纸张的厚度必须是正数
        if (peakHeight > 0 && paperHeight > 0) {
            // b、定义计数变量，用于记录纸张折叠的次数
            int count = 0;

            // c、while循环:
            /**
             * 循环条件：当纸张折叠的高度 小于 山峰的高度时，就循环折叠纸张
             * 循环结束条件：当纸张折叠的高度 大于等于 山峰的高度时，循环结束
             */
            while (paperHeight < peakHeight) {
                // d、纸张每折叠一次，就是上一次的2倍
                paperHeight *= 2;

                // e、纸张每折叠一次，累加纸张折叠的次数
                count++;
            }

            // f、while循环结束，说明纸张的高度 大于等于 山峰的高度了，返回折叠的次数
            return count;
        }

        // g、如果程序走到这里，说明没有进入if判断语句，说明山峰的高度 和 纸张的厚度不是正数，返回 -1
        return -1;
    }
}

      • 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
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 控制台输出结果：
      纸张需要折叠27次，才可以折成珠穆朗玛峰的高度！

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
    验证结果是否正确

    • 第一步：Win+R键(打开运行窗口)，输入calc(打开计算器)，然后按回车。

      在这里插入图片描述

    • 第二步：在计算器中输入0.1 乘以 2

      在这里插入图片描述

    • 第三步：单击等于27次，自己数次数：

      在这里插入图片描述

      在这里插入图片描述

    二、力扣算法题

    1、回文数

    • 需求：

      • 给一个整数n(指的是任意整数)，如果n是一个回文数，打印true，否则返回false。
      • 解释：
        • 回文数是指正序（从左往右） 和 倒序（从右往左）读都是一样的整数。
        • 例如：1221、121…是；123、12345…不是。
      • 注意：核心思想就是把数字倒过来跟原来的数字进行比较。

    • 实现：

      package com.app.demo8_while_practice;

/**
    while循环结构的练习
        力扣算法题：
            回文数：
                给一个整数 n(指的是任意整数)，如果n是一个回文整数，打印true，否则返回false
                解释：回文数是指正序（从左向右） 和 倒序（从右向左）读都是一样的整数。
                例如：121是回文数，而123不是

                注：核心思想就是把数字倒过来跟原来的数字进行比较
 */
public class WhileDemo2 {
    public static void main(String[] args) {
        // 1、调用判断回文数的方法，需要接收返回结果或直接输出
        System.out.println(isPalindromeNumber(1221));
        System.out.println(isPalindromeNumber(1234567));
        System.out.println(isPalindromeNumber(232));
    }

    /**
     * 2、定义判断回文数的实现方法
     *
     * @param n 任意整数：123、121、12345
     * @return  是回文数返回true，不是返回false
     */
    private static boolean isPalindromeNumber(int n) {
        // a、接收到n的值后，定义一个临时变量存储n的值，用于最后与倒过来后的n的值做比较！
        int temp = n;

        // b、定义num变量，初始值为0，用于记录倒过来后的n
        int num = 0;

        // c、while循环
        while (n != 0) {
            // 从右往左获取每一位数字
            int ge = n % 10;
            // 此时n的值已经被拿走一个了，需要修改一下n的值
            n /= 10;    // 等价于——> n = n / 10;
            // 把当前获取到的数字拼接到最右边（将数字倒过来）
            num = num * 10 + ge;
        }

        // d、此时n的值已经倒过来了
//        System.out.println("原来的n: " + temp); // 注意：原来的n的值已经存储在临时变量temp里了
//        System.out.println("倒过来后的n: " + num);

        // e、判断倒过来后的n 是否与 原来的n相等(注意：原来的n的值已经存储在临时变量temp里了)
        if (num == temp) {
            // true: 相等，n是回文数，返回true
            return true;
        }else {
            // false: 不相等，n不是回文数，返回false
            return false;
        }


        /**
         * while循环解析：
         *      循环条件：只要n的值不为0，就一直循环
         *      循环体代码解析：
         *          (1) int ge = n % 10;
         *          上面这句代码的意思是：
         *              假如n的值是1234:
         *                  1234 % 10 ==> 1234 / 10=123.4 取余数: 4, 将4赋值给int类型的变量ge
         *          (2) n /= 10;
         *          上面这句代码的意思是：
         *              n /= 10 ==> n = n / 10 ==> 1234 / 10=123(int类型是直接不要小数点后的数),
         *                  将123赋值给int类型的变量n, 此时n的值由原来的1234 变成了 123。
         *          (3) num = num * 10 + ge;
         *          上面这句代码的意思是：
         *              num = num * 10 + ge ==> 0 * 10 + 4=4, 将4赋值给int类型的变量num。
         *
         * -------------------------------------------------------------
         *
         * while循环执行流程解析：
         *      拿 n = 1234 这个例子来讲：
         *      (1) n != 0: 开始判断，n=1234，因此符合 n!=0，开始循环：
         *          第一次循环：
         *              a. 执行：int ge = n % 10;
         *                  n % 10 ==> 1234 / 10=123.4, 取余数4后，赋值给变量ge。
         *              b. 执行：n /= 10;
         *                  n /= 10 ==> 1234 / 10=123, 将123赋值给变量n, 此时n的值由原来的1234 变成 123。
         *              c. 执行：num = num * 10 + ge;
         *                  num * 10 + ge ==> 0 * 10 + 4 = 0+4 = 4, 将4赋值给变量num, 此时num的值由原来的0 变成 4
         *      (2) n != 0: 开始判断，n=123，因此符合 n!=0，开始循环：
         *          第二次循环：
         *              a. 执行：int ge = n % 10;
         *                  n % 10 ==> 123 / 10=12.3, 取余数3后，赋值给变量ge。
         *              b. 执行：n /= 10;
         *                  n /= 10 ==> 123 / 10=12, 将12赋值给变量n, 此时n的值由原来的123 变成 12。
         *              c. 执行：num = num * 10 + ge;
         *                  num * 10 + ge ==> 4 * 10 + 3 = 40+3 = 43, 将43赋值给变量num, 此时num的值由原来的4 变成 43
         *      (3) n != 0: 开始判断，n=12，因此符合 n!=0，开始循环：
         *          第三次循环：
         *              a. 执行：int ge = n % 10;
         *                  n % 10 ==> 12/ 10=1.2, 取余数2后，赋值给变量ge。
         *              b. 执行：n /= 10;
         *                  n /= 10 ==> 12 / 10=1, 将1赋值给变量n, 此时n的值由原来的12 变成 1。
         *              c. 执行：num = num * 10 + ge;
         *                  num * 10 + ge ==> 43 * 10 + 2 = 430+2 = 432, 将432赋值给变量num, 此时num的值由原来的43 变成 432
         *      (4) n != 0: 开始判断，n=1，因此符合 n!=0，开始循环：
         *          第四次循环：
         *              a. 执行：int ge = n % 10;
         *                  n % 10 ==> 1/ 10=0.1, 取余数1后，赋值给变量ge。
         *              b. 执行：n /= 10;
         *                  n /= 10 ==> 1 / 10=0, 将0赋值给变量n, 此时n的值由原来的1 变成 0。
         *              c. 执行：num = num * 10 + ge;
         *                  num * 10 + ge ==> 432 * 10 + 1 = 4320+1 = 4321, 将4321赋值给变量num, 此时num的值由原来的432 变成 4321
         *      (5) n != 0: 开始判断，n=0，因此不符合 n!=0，结束循环
         */
    }
}

      • 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
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 控制台输出结果：
      true
false
true

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
    2、求商和余数

    • 需求：

      • 给定两个整数，被除数和除数（都是正数，且不超过int的范围）。
      • 将两个数进行相除，要求不使用乘法、除法和%运算符。
      • 得到商和余数。

    • 分析：

      • 被除数 / 除数 = 商 … 余数

    • 实现：

      package com.app.demo8_while_practice;

import java.util.Scanner;

/**
    while循环结构的练习
        求商和余数：
            给定两个整数，被除数和除数（都是正数，且不超过int的范围）。
            将两个数进行相除，要求不使用乘法、除法和%运算符
            得到商和余数。
 */
public class WhileDemo3 {
    public static void main(String[] args) {
        // 1、创建键盘录入对象，用于录入被除数和除数
        Scanner sc = new Scanner(System.in);
        
        // 2、录入被除数和除数
        System.out.println("请您输入被除数：");
        int dividend = sc.nextInt();
        System.out.println("请您输入除数：");
        int divisor = sc.nextInt();

        // 3、调用求商和余数的方法，传入被除数和除数
        consultAndRemainder(dividend, divisor);
    }

    /**
     * 4、定义求商和余数的实现方法
     * @param dividend      被除数
     * @param divisor       除数
     */
    private static void consultAndRemainder(int dividend, int divisor) {
        // 注意：要求不能使用乘法、除法、%运算符
        /**
         * a.while循环：
         *      循环条件：只要被除数是 大于等于 除数的，就不断循环
         *      结束条件：当被除数 小于 除数时，就结束循环
         */
        // 定义计数变量，用于记录被除数减除数的次数
        int count = 0;
        while (dividend >= divisor) {
            // b、开始循环：每循环一次，被除数就 减 除数一次
            dividend -= divisor;    // ==> dividend = dividend - divisor;

            // c、每相减一次，计数变量就记录一次
            count++;
        }

        // d、循环结束之后，此时的dividend里的值就是余数
        System.out.println("余数：" + dividend);

        // e、被除数 和 除数相减的次数就是商
        System.out.println("商：" + count);
    }
}

      • 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
      • 控制台输出结果：
      请您输入被除数：
5
请您输入除数：
2
余数：1
商：2

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
  • 相关阅读:
    helm3 快速部署 Harbor 镜像仓库
    Java泛型
    MySQL中修改注释+报错1067错误时的解决方法
    【操作系统——内存连续分配管理方式】
    python 数据保存为npy和npz格式并读取
    Java 集合之 Set 接口
    算法训练 第四周
    Git：Git的一些基本操作
    程序员5分钟，带你看完24岁60W年薪架构师的简历，上面竟然写着精通JVM
    LLM应用实战：当KBQA集成LLM
  • 原文地址：https://blog.csdn.net/yelitoudu/article/details/127563247