Java 取模和取余

清疚 2023-09-27 16:29 115阅读 0赞

Java 取余和取模都是计算一个整数除以另一个整数后所得到余数。计算原理如下：

1.  取余运算符 % 表示求余数运算，计算公式为 a % b = r，其中 a 和 b 分别表示被除数和除数，r 表示所得到的余数。这个运算符将 a 除以 b，并返回余数 r。需要注意的是，如果 a 符号为正，则 r 的符号也为正；如果 a 符号为负，则 r 的符号也为负。

1.  取模方法 Math.floorMod() 表示对余数进行修正运算，计算公式为 Math.floorMod(a, b) = r'，其中 a 和 b 同样分别表示被除数和除数，r' 表示修正后的余数。这个方法先通过 % 运算符计算出原始的余数 r，然后根据 r 和 b 的符号来调整 r 的值，得到最终的余数 r'。如果 b 的符号为正，则 r' 的范围在 \[0, |b|) 之间；如果 b 符号为负，则 r' 的范围在 (|b|, 0\] 之间。

***被除数÷除数= (a÷b=c)******商...余数***

*通常取模运算也叫取余运算，它们返回结果都是余数 .rem 和 mod 唯一的区别在于:*

*x 和 y 的正负号一样的时候，两个函数结果是等同的；当 x 和 y 的符号不同时，rem 函数结果的符号和 x 的一样，而 mod 和 y 一样*

*但是python（里面%是取模运算）和c++（里面%是取余不是取模）*

*两个异号整数取模取值规律 （当为小数时也是这个运算规律，这点好像与 C 语言不太一样）*

*无论除数或者被除数是否为负数，先将两个整数看作是正数，(即取绝对值先进行计算),得到商的绝对值，再作除法运算:*

*1、能整除时，其值为 0*

*2、不能整除时，取余结果=除数×(整商+1)-被除数;*

当被除数和除数均为正数时：

*  取余运算符 %：10 % 3 = 1，因为 10 ÷ 3 = 3 余 1；

*  取模方法 Math.floorMod()：Math.floorMod(10, 3) = 1，也是因为 10 ÷ 3 = 3 余 1。

当被除数为负数，除数为正数时：

*  取余运算符 %：-10 % 3 = -1，因为 -10 ÷ 3 = -3 余 -1，而符号与被除数相同，所以余数为 -1；

*  取模方法 Math.floorMod()：Math.floorMod(-10, 3) = 2，因为 -10 ÷ 3 = -3 余 -1，而修正后的余数为 \[2, 3)，即 2。

当被除数为正数，除数为负数时：

*  取余运算符 %：10 % -3 = 1，因为 10 ÷ -3 = -3 余 1，而余数的符号与被除数相同，所以余数为 1；

*  取模方法 Math.floorMod()：Math.floorMod(10, -3) = -2，因为 10 ÷ -3 = -3 余 1，而修正后的余数为 (-3, -2\]，即 -2。

当被除数和除数均为负数时：

*  取余运算符 %：-10 % -3 = -1，因为 -10 ÷ -3 = 3 余 -1，而符号与被除数相同，所以余数为 -1；

*  取模方法 Math.floorMod()：Math.floorMod(-10, -3）= -1，也是因为 -10 ÷ -3 = 3 余 -1。

public class Main {
    public static void main(String[] args) {
            int a = -5;
            int b = 10;
            int c = -11;
            int d = -10;
            System.out.println(a/b);//0
            System.out.println(a%b);//-5
            System.out.println(c%d);//-1
        }
    }

Java中的取模和取余可以应用于很多编程场景中，例如：

1.  数字处理：在需要对两个数进行除法运算后获取余数时，可以使用取模或取余。这个场景通常应用于数字验证、校验等功能上。

（**%:**任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。将一个数值限制在0到9之间，可以通过对其进行取模操作实现）

例如实现判断实现某个数是否为水仙花数：

/**
     * 水仙花数，如: 153 = 1^3+5^3+3^3
     * 统计100 到1000 中有多少个三位数的水仙花数
     * / 除号：整数除和小数除是有区别的。整数之间做除法时，只保留整数部分而舍弃小数部分
     * 例如 10.0 / 4 = 2.5，10 / 4 =2 。所以 153 / 100 = 1
     * % 取模，取余：本质是 a % b = a - a / b * b。但是我们一般认为是其被除之后的余数
     * 例如 10 / 3 = 1。所以 153 % 100 = 53，然后 53 / 10 = 5
     * int a=i % 10;   //个位
     * int b=i /10 %10; //十位
     * int c=i /100 %10; //百位
     */
        public class ShaiXianHa {
            public static void main(String[] args) {
                int count = 0; // 计数器变量
                for (int m = 90; m < 10000; m++) { // 将循环范围修改为 90 ~ 10000
                    if (m < 100 || m > 999) { // 判断是否为三位数
                        //使用 continue 和 break 的效果是不同的，使用 continue 可以跳过当前循环，进入下一个循环；
                        // 而使用 break 可以立即退出循环，不再进行后续的循环。
                        // 在本题中，如果使用 break 来代替 continue，会导致程序在找到第一个不满足条件的数时就立刻退出循环
                        // 而没有遍历完所有的数，因此无法正确统计出符合条件的水仙花数的个数。
                        //例如，如果将代码中的 continue 改为 break，则程序只能找到第一个不符合条件的数，
                        // 并输出结果为 0 个水仙花数，这显然是不正确的。
                        continue; // 如果不是三位数，跳过本次循环
                    }
                    int b3 = m / 100;
                    int b2 = (m % 100) / 10;
                    int b1 = m % 10;
                    if (m == (b3 * b3 * b3) + (b2 * b2 * b2) + (b1 * b1 * b1)) { // 判断是否为水仙花数
                        System.out.println(m + "是一个水仙花数");
                        count++; // 每找到一个水仙花数，计数器加 1
                    }
                }
                System.out.println("三位数的水仙花数共有" + count + "个");
            }
        }

1.  日期计算：在Java程序开发中，需要进行日期和时间的处理和比较。其中，取余运算符 % 能够很好地用于时间戳的计算、日期的周期性检测等。

例如实现判断闰年：

public class RunYear {
        public static void main(String[] args) {
            int count = 0 ;
            for(int year= 2000; year <= 3000;year++){ 
                //闰年定义：能够被 4 整除但不能被 100 整除的年份，或者能够被 400 整除的年份均为闰年
                //if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)// 判断是否为闰年
                if(year % 400 == 0 || year % 4 == 0 && year % 100 != 0){
                    //\n 是一个特殊字符，表示换行符，用于将输出结果换行显示；而 \t 代表制表符，用于产生一个制表符的空格。
                    //因此，"%d是闰年\n",year 的作用是将 "year是闰年" 这个字符串输出到控制台，并将 year 的值替换为实际的年份，
                    // 同时在末尾加上一个换行符，使得下一条输出语句可以从新的一行开始输出。
                    //而"%d是闰年\t",year 的作用则是将 "year是闰年" 这个字符串输出到控制台，并将 year 的值替换为实际的年份
                    //同时在末尾加上一个制表符的空格，用于在同一行输出下一个元素。
                    //例如，如果当前的年份为 2000，则输出结果为 "2000是闰年    "（这里的空格代表一个制表符）。
                    System.out.printf("%d是闰年\t",year);
                    count++; // 如果是闰年，计数器加 1
                }else {
                    System.out.println(year + "不是闰年");
                }
            }System.out.println("2000年到3000年中共有 " + count + " 个闰年");
        }
    }

1.  奇偶判断：在判断一个整数是偶数还是奇数时，可以使用取模或者取余。具体来说，如果一个数除以2的余数为0，则表示该数为偶数；否则，表示该数为奇数。

int num = 15;
    if (num % 2 == 0) {
        System.out.println("该数为偶数");
    } else {
       System.out.println("该数为奇数");
    }

1.  加密算法：在一些加密算法中，也需要使用取余或取模运算，例如RSA加密算法、哈希算法等。

（在RSA算法中，在加密操作中，我们使用公钥进行模幂运算，即将原始数据使用公钥的指数进行加密，并对结果进行取模操作，得到加密后的数据。在解密操作中，我们使用私钥进行模幂运算，即将加密后的数据使用私钥的指数进行解密，并对结果进行取模操作，得到原始数据。）