在Java中，整数必须介于2 ^ 31-1到-2 ^ 31之间
所以如果int x = 2 * 1500000000
逻辑答案将为300000000，但由于它的值有限制，因此将其提早，并使用2 ^ 32 mod 3000000000将其变为-1294967296，但由于提早，该数字将变为负数，因为正字段溢出。我是否可以说这是真的？
另外，我在调制部分上进行了搜索和读取，例如在时钟里
15 mod 12 == 3，因为它是除法的余数，但是它很好地用作时钟的示例，因为此处12是常数。
那么2 ^ 32是否为整数的所有整数调制计算的常量？
最佳答案
为了简单起见，我将使用8位整数。
以二进制形式，从00000000b到11111111b的8位范围。
00000000b = 0d
11111111b = 255d
那么计算机如何将符号添加到整数？是two's complement。
对于无符号整数，我们通过以下方式将
11111111b从二进制转换为denary： 11111111b
= 1*2^7 + 1*2^6 + 1*2^5 + 1*2^4 + 1*2^3 + 1*2^2 + 1*2^1 + 1*2^0
= 1*128 + 1*64 + 1*32 + 1*16 + 1*8 + 1*4 + 1*2 + 1*1
= 255d
那么有符号整数
11111111b呢？这是一个简单的方法： v----------(sign flag 1=negative)
11111111b
= 1*(-2^7) + 1*2^6 + 1*2^5 + 1*2^4 + 1*2^3 + 1*2^2 + 1*2^1 + 1*2^0
= 1*(-128) + 1*64 + 1*32 + 1*16 + 1*8 + 1*4 + 1*2 + 1*1
= -1d
通常，签名数字的最高有效位是符号标志。
要将否定拒绝数转换为二进制补码：
-18d
========
without sign 0001 0010
one's complement 1110 1101 (inverted)
*two's complement 1110 1110 (one's complement + 1)
8位有符号整数的范围是从
-2^7到2^7-1。现在什么是溢出？让我们来看看：
01111111b
= 127d
01111111b + 1
= 10000000b
= 1*(-2^7) + 0*2^6 + 0*2^5 + 0*2^4 + 0*2^3 + 0*2^2 + 0*2^1 + 0*2^0
= 1*(-128) + 0*64 + 0*32 + 0*16 + 0*8 + 0*4 + 0*2 + 0*1
= -128d
127d + 1d
=========
0111 1111 (127d) +
+0000 0001 (1d) +
----------
1000 0000 (-128d) - (overflow)
因此，如果将1加到最大的8位有符号整数，则结果是最小的8位有符号整数。 + ve + + ve-> -ve是溢出错误。
减法呢？ 45-16？ （+ ve + -ve-> + ve）
45d - 16d
=========
0010 1101 (45d) +
+1111 0000 (-16d) -
----------
1 0001 1101 (29d) +
^---------------------(discard)
45-64呢？ （+ ve + -ve-> -ve）
45d - 64d
=========
0010 1101 (45d) +
+1100 0000 (-64d) -
----------
1110 1101 (-19d) -
-64-64呢？ （-ve + -ve-> -ve）
-64d - 65d
=========
1100 0000 (-64d) -
+1100 0000 (-64d) -
----------
1 1000 0000 (-128d) +
^---------------------(discard)
-64-65怎么样？
-64d - 65d
=========
1100 0000 (-64d) -
+1011 1111 (-65d) -
----------
1 0111 1111 (127d) + (underflow)
^---------------------(discard)
因此-ve + -ve-> + ve是一个下溢错误。
32位整数的情况与此类似，只有更多位可用。
对于您的问题
2*1500000000，如果我们将它们视为32位无符号整数，则结果为3000000000，其二进制表示为： 1011 0010 1101 0000 0101 1110 0000 0000
= 1*2^31 + 0*2^30 + ...
= 1*2147483648 + 0*1073741824 + ...
= 3000000000d
但是，如果我们将其视为32位有符号整数：
v------(Let's recall this is the sign flag)
1011 0010 1101 0000 0101 1110 0000 0000
= 1*(-2^31) + 0*2^30 + ...
= 1*(-2147483648) + 0*1073741824 + ...
= -1294967296d
添加：无符号整数溢出
无符号整数的溢出非常相似：
11111111b
= 255d
11111111b + 1
= 00000000b
= 0d
255d + 1d
=========
1111 1111 (255d) +
+0000 0001 (1d) +
----------
1 0000 0000 (0d) - (overflow)
^---------------------(discard)
这就是为什么对于32位无符号整数始终为
mod 2^32。顺便说一句，这不仅适用于Java，而且适用于大多数编程语言，例如C / C ++。其他一些编程语言可能会自动处理溢出并将类型更改为更高的精度或浮点，例如PHP / JavaScript。
关于java - ^ 32限制和取模方法，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/11281703/