我将这些大型随机操作循环作为基准测试（仅仅因为我很好奇）并遇到了一些我不明白的事情。无论我为大循环输入什么，它总是产生相同的结果。这是我正在谈论的部分的代码。
public int stuff;
public int result;
myJavaProgram(String[] cmdArguments)
{
stuff=1;
superLoopCalcualtion();
System.out.println(stuff+" converted to result:"+result);
stuff=12345;
superLoopCalcualtion();
System.out.println(stuff+" converted to result:"+result);
stuff=9823450;
superLoopCalcualtion();
System.out.println(stuff+" converted to result:"+result);
}
public void superLoopCalcualtion()
{
int a=stuff;
int b=a+99;
int z=0;
for (z = 0; z < 200000; z++)
{
a=a+22;
b=a*44;
a=b+1234;
}
result=a;
}
输出就是这个
1 converted to result:1398361394
12345 converted to result:1398361394
9823450 converted to result:1398361394
没有办法可以正确......对吧？
答案 0 :(得分：7)
你在这里看到的是（伪装）溢出，导致有效乘法因子为0，从而有效地结束循环中的值变化。
为了看到这一点，让我们考虑使用byte的简化代码示例，它允许循环更短：
byte a = stuff;
for (byte z = 0; z < 8; z++) {
a = (byte) (a * 2);
}
我省略了代码，每次迭代都会以十进制和二进制形式很好地打印数字。以下是stuff为1,11和127（Byte.MAX_VALUE）的结果：
1
---
0: 1 00000001
1: 2 00000010
2: 4 00000100
3: 8 00001000
4: 16 00010000
5: 32 00100000
6: 64 01000000
7: -128 10000000
8: 0 00000000
11
---
0: 11 00001011
1: 22 00010110
2: 44 00101100
3: 88 01011000
4: -80 10110000
5: 96 01100000
6: -64 11000000
7: -128 10000000
8: 0 00000000
127
---
0: 127 01111111
1: -2 11111110
2: -4 11111100
3: -8 11111000
4: -16 11110000
5: -32 11100000
6: -64 11000000
7: -128 10000000
8: 0 00000000
要理解这一点，请考虑将二进制数乘以2会从右侧添加0。如果我们不断地这样做，我们会“推”出我们的数据结构可以容纳的范围之外的左边的数字。对于byte，范围是8位。因此，在将8倍乘以2之后，我们保证无论预先包含的数量是多少，现在都是0 s。继续没有任何影响，因此我们达到了停滞状态（或陈旧性，无论这个术语是什么）。
在“可见”范围之外推送有效位称为 overflow ，因为二进制表示不能包含它们并且它们......溢出。在十进制中，这会导致符号 1 的更改。如果你看一下1的例子，那个溢出只发生在最后一次迭代，因为数字足够小，这相当于说它右边有很多可用空间。另一方面，127会立即溢出，因为它是byte的最大值，也就是说，需要所有位。
1 在Java中，所有数字都已签名。
从这里开始，我们需要逐步增加复杂性，直到我们到达您的代码，但潜在的现象是相同的。
对于初学者，我们可以使用short，int和long来增加我们的二进制表示能力，但这只会延迟不可避免的。我们不需要8次迭代，而是分别需要12, 32 and 64。
接下来，我们可以改变乘法因子。偶数只是2的乘法，所以我们将得到相同的结果。请注意，对于2^n的特殊情况，我们将始终更快地达到结果，因为我们实际上只是减少迭代。但是，如果是奇数，我们永远不会达到（十进制）0;溢出将永远跳过它，我们将再次达到我们的起始号码。对于64（stuff = 1）次迭代，这里是3（字节），乘法因子为Byte.MAX_VALUE / 2 + 1：
1
---
0: 1 00000001
1: 3 00000011
2: 9 00001001
3: 27 00011011
4: 81 01010001
5: -13 11110011
6: -39 11011001
7: -117 10001011
8: -95 10100001
9: -29 11100011
10: -87 10101001
11: -5 11111011
12: -15 11110001
13: -45 11010011
14: 121 01111001
15: 107 01101011
16: 65 01000001
17: -61 11000011
18: 73 01001001
19: -37 11011011
20: -111 10010001
21: -77 10110011
22: 25 00011001
23: 75 01001011
24: -31 11100001
25: -93 10100011
26: -23 11101001
27: -69 10111011
28: 49 00110001
29: -109 10010011
30: -71 10111001
31: 43 00101011
32: -127 10000001
33: -125 10000011
34: -119 10001001
35: -101 10011011
36: -47 11010001
37: 115 01110011
38: 89 01011001
39: 11 00001011
40: 33 00100001
41: 99 01100011
42: 41 00101001
43: 123 01111011
44: 113 01110001
45: 83 01010011
46: -7 11111001
47: -21 11101011
48: -63 11000001
49: 67 01000011
50: -55 11001001
51: 91 01011011
52: 17 00010001
53: 51 00110011
54: -103 10011001
55: -53 11001011
56: 97 01100001
57: 35 00100011
58: 105 01101001
59: 59 00111011
60: -79 10110001
61: 19 00010011
62: 57 00111001
63: -85 10101011
64: 1 00000001
我不想那么多地学习数学，因为我觉得这不属于问题的范围。可以说，在MAX_VALUE / 2 + 1迭代中，您将再次到达起始编号（对于某些数字也在此之前）。
关键是你的44是偶数，所以你得到了停滞不前的结果。
现在进行添加操作。在乘法之前和之后，尽可能多地使用它们，它只会将结果更改为常量。效果保持不变。考虑
for (byte z = 0; z < 10; z++) {
a = (byte) (a + 1);
a = (byte) (a * 2);
}
结果是
1
---
0: 1 00000001
1: 4 00000100
2: 10 00001010
3: 22 00010110
4: 46 00101110
5: 94 01011110
6: -66 10111110
7: 126 01111110
8: -2 11111110
9: -2 11111110
10: -2 11111110
所以我们在-2停滞不前。在十进制中，您可以使用循环公式轻松地看到这一点：(-2 + 1) * 2 = -2。循环中数字的“随机”选择导致（确定性地）在约15次迭代后确定数量1398361394（使用long s将通过一定次数的迭代延迟此结果）。只需通过迭代进行数学迭代，您将得到如上所述的循环公式。
小心溢出！确保您选择的数据结构始终足以包含您正在使用的数字范围。最糟糕的情况是，你有（非原始）类型BigInteger用于任意精度（但速度要慢得多）。无论上面讨论的任何参数如何，一旦你溢出你的数学结果将是错误的（除非你是故意进行溢出数学）。