Java取余运算怎么用，%操作符入门教程

小伙伴们对文章编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《Java如何用%求余数，取余运算入门教程》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

在Java中，取余运算符%的结果符号与被除数一致，其计算逻辑为a % b = a - (a / b) * b，其中整数除法会截断小数部分。1. 该运算符适用于整数和浮点数类型，结果符号由被除数决定；2. Java的%是余数运算符而非数学模运算，数学模运算要求结果非负，而Java中-10 % 3的结果为-1；3. 若要实现数学上的模运算，可使用(num % mod + mod) % mod确保结果非负；4. 常见应用场景包括判断奇偶、循环数组索引、时间单位转换、数字位提取和哈希分桶。因此，理解%运算符的行为对正确处理周期性和数学计算至关重要。

在Java里，要计算两个数的余数，你直接用百分号 % 这个运算符就行。它是一个二元运算符，用法很简单，就是 a % b，其中 a 是被除数，b 是除数。这个操作会返回 a 除以 b 之后剩下的余数。

解决方案

Java的取余运算符 % 用起来非常直观。当你写 int result = dividend % divisor; 时，result 就会得到 dividend 被 divisor 整除后的余数。这个运算符不仅能用于整数类型（byte, short, int, long），也能用于浮点类型（float, double），不过在浮点数上用得相对少一些，而且结果的精度可能会有些出乎意料。

需要注意的是，结果的符号会和被除数（也就是 % 左边的那个数）的符号保持一致。如果被除数是正数，结果就是正数或零；如果被除数是负数，结果就是负数或零。

比如：

int a = 10;
int b = 3;
int remainder1 = a % b; // 10 除以 3，余数是 1

int c = -10;
int d = 3;
int remainder2 = c % d; // -10 除以 3，余数是 -1

int e = 10;
int f = -3;
int remainder3 = e % f; // 10 除以 -3，余数是 1

int g = -10;
int h = -3;
int remainder4 = g % h; // -10 除以 -3，余数是 -1

double x = 10.5;
double y = 3.0;
double remainder5 = x % y; // 10.5 除以 3.0，余数是 1.5

System.out.println("10 % 3 = " + remainder1);
System.out.println("-10 % 3 = " + remainder2);
System.out.println("10 % -3 = " + remainder3);
System.out.println("-10 % -3 = " + remainder4);
System.out.println("10.5 % 3.0 = " + remainder5);

运行这段代码，你会看到： 10 % 3 = 1-10 % 3 = -110 % -3 = 1-10 % -3 = -110.5 % 3.0 = 1.5

这和我们小学数学里“余数不能为负”的概念有点不一样，但这就是Java（以及C/C++等多数编程语言）的 % 运算符的定义。

Java中取余运算符（%）的工作原理是什么？

Java的 % 运算符，说白了，它的计算逻辑是这样的：a % b 的结果等于 a - (a / b) * b。这里的 a / b 呢，如果是整数除法，它会直接截断小数部分，只保留整数商。这也就是为什么结果的符号会跟随被除数 a 的原因。

举个例子，我们拿 -10 % 3 来说：

1. 首先计算 a / b，也就是 -10 / 3。在整数除法中，这个结果是 -3（因为 -3.33 截断后就是 -3）。
2. 然后计算 (a / b) * b，即 (-3) * 3，结果是 -9。
3. 最后计算 a - (a / b) * b，也就是 -10 - (-9)，结果就是 -1。

所以，-10 % 3 得到 -1。这个机制是相当明确的，一旦你理解了它背后的数学逻辑，就不会觉得它“奇怪”了。它不是一个简单的“剩余”概念，而是一个基于整数除法截断规则的定义。这在某些场景下非常有用，比如当你需要一个结果的符号与原数保持一致时。但如果你想要的是一个总是非负的“数学意义上的模”，那可能还需要额外处理一下。

在Java中，取余运算（%）与数学中的模运算有何不同？

这确实是个容易让人混淆的点。在纯数学领域，尤其是数论中，模运算（modulo operation）通常定义为结果必须是非负的。也就是说，a mod n 的结果 r 必须满足 0 <= r < |n|。比如，数学上 -10 mod 3 的结果应该是 2，因为 (-4 * 3) + 2 = -10，且 2 在 0 到 3 之间。

但就像前面提到的，Java的 % 运算符，它的结果的符号是取决于被除数（左边的操作数）。所以，Java 的 % 严格来说是“余数运算符”（remainder operator），而不是“模运算符”（modulo operator）。

主要区别在于：

• 符号： Java的 % 结果符号与被除数相同。数学上的模运算结果通常是非负的。
• 应用场景： Java的这种行为在很多计算机科学的场景下是直接可用的，比如循环数组索引时，index = (index + 1) % length，即使 index 暂时变成负数（虽然通常会避免），结果也会是正确的。但如果需要严格的数学模运算，比如在加密算法或者哈希函数中，你就得自己做额外处理了。

如果你在Java里确实需要一个总是非负的数学模运算结果，你可以这样做：

int num = -10;
int mod = 3;
// 这种方式可以得到一个总是非负的数学模运算结果
int mathematicalMod = (num % mod + mod) % mod;
System.out.println("数学上的 -10 mod 3 = " + mathematicalMod); // 输出 2

这个小技巧 (num % mod + mod) % mod 能够确保最终结果落在 [0, mod) 的区间内，无论 num % mod 的结果是正还是负。理解这个差异，在处理涉及周期性、循环或数学精确性计算时，是至关重要的。

Java取余运算（%）在实际编程中有哪些常见应用场景？

% 运算符在日常编程中用得非常多，它能解决不少实际问题。我个人觉得，这玩意儿虽然简单，但用得巧，能让代码简洁不少。

1. 判断奇偶数： 这是最基础也是最常见的用法。

   int number = 7;
   if (number % 2 == 0) {
       System.out.println(number + " 是偶数。");
   } else {
       System.out.println(number + " 是奇数。"); // 输出：7 是奇数。
   }

2. 循环数组索引/周期性操作： 当你需要在一个固定大小的数组或列表中循环访问元素时，% 能帮你把索引值限制在有效范围内。

   String[] days = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
   int currentIndex = 5; // 比如今天是周六
   int nextDayIndex = (currentIndex + 1) % days.length; // (5 + 1) % 7 = 6
   int nextNextDayIndex = (currentIndex + 2) % days.length; // (5 + 2) % 7 = 0 (周日过后是周一)
   System.out.println("明天是: " + days[nextDayIndex]); // 输出：明天是: Sun
   System.out.println("后天是: " + days[nextNextDayIndex]); // 输出：后天是: Mon

3. 时间单位转换： 将秒数转换为分钟、小时、天等。

   int totalSeconds = 3665; // 1小时1分钟5秒
   int seconds = totalSeconds % 60;
   int totalMinutes = totalSeconds / 60;
   int minutes = totalMinutes % 60;
   int hours = totalMinutes / 60;
   System.out.println(totalSeconds + " 秒是 " + hours + " 小时 " + minutes + " 分钟 " + seconds + " 秒。");
   // 输出：3665 秒是 1 小时 1 分钟 5 秒。

4. 数字位提取： 比如你想获取一个整数的个位、十位等。

   int num = 12345;
   int lastDigit = num % 10; // 5
   int tensDigit = (num / 10) % 10; // 4
   System.out.println("个位是: " + lastDigit);
   System.out.println("十位是: " + tensDigit);

5. 哈希函数或数据分桶： 在数据结构中，比如哈希表，% 经常用来将一个哈希值映射到数组的某个索引上。

   int hashCode = "exampleString".hashCode();
   int bucketSize = 16; // 比如哈希表有16个桶
   int bucketIndex = Math.abs(hashCode % bucketSize); // 使用绝对值确保索引非负
   System.out.println("该字符串应放入的桶索引是: " + bucketIndex);

   这里用 Math.abs() 是为了避免负数哈希值导致负数索引，虽然Java的 % 结果符号跟随被除数，但数组索引必须是非负的。

这些场景仅仅是冰山一角，% 运算符的灵活性和实用性，让它成为编程工具箱里不可或缺的一员。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。