blocks|key|62517|text|在中间的某个地方，你会得到0作为产品。因此，您的整个乘积将为0。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|62518|在您的案例中：|62519|for+(int+i+=+10;+i+<+99;+i%2B%2B)+{
++++if+(product+<+Integer.MAX_VALUE)
++++++++System.out.println(product);
++++product+*=+i;
}
//+System.out.println(product);

System.out.println(-2147483648+*+EvenValueOfi);+//+-->+this+is+the+culprit+(Credits+:+Kocko's+answer+)

O/P+:
1
10
110
1320
17160
240240
3603600
57657600
980179200
463356416
213837312
-18221056
-382642176
171806720
-343412736
348028928
110788608
-1414463488
464191488
112459776
-1033633792
-944242688
793247744
-385875968
150994944
838860800
-704643072
402653184
2013265920
-805306368
-1342177280++-->+Multiplying+this+and+the+current+value+of+`i`+will+also+give+-2147483648+(INT+overflow)
-2147483648++-->+Multiplying+this+and+the+current+value+of+`i`+will+also+give+-2147483648+(INT+overflow)

-2147483648++->++Multiplying+this+and+the+current+value+of+'i'+will+give+0+(INT+overflow)
0
0
0|code-block|syntax|javascript|62520|每次将i的当前值与数字相乘时，都会得到0作为输出。|62521|entityMap^0|D|1|0|0|0|3|1|J|1|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

Somewhere in the middle you get <code>0</code> as the product. So, your entire product will be 0.

In your case :

<pre><code>for (int i = 10; i &lt; 99; i++) {
 if (product &lt; Integer.MAX_VALUE)
 System.out.println(product);
 product *= i;
}
// System.out.println(product);

System.out.println(-2147483648 * EvenValueOfi); // --&gt; this is the culprit (Credits : Kocko's answer )

O/P :
1
10
110
1320
17160
240240
3603600
57657600
980179200
463356416
213837312
-18221056
-382642176
171806720
-343412736
348028928
110788608
-1414463488
464191488
112459776
-1033633792
-944242688
793247744
-385875968
150994944
838860800
-704643072
402653184
2013265920
-805306368
-1342177280 --&gt; Multiplying this and the current value of `i` will also give -2147483648 (INT overflow)
-2147483648 --&gt; Multiplying this and the current value of `i` will also give -2147483648 (INT overflow)

-2147483648 -&gt; Multiplying this and the current value of 'i' will give 0 (INT overflow)
0
0
0
</code></pre>

Every time you multiply the current value of <code>i</code> with the number you get <code>0</code> as output.

blocks|key|4568739|text|由于许多现有的答案都指向Java和调试输出的实现细节，让我们来看看二进制乘法背后的数学原理，以真正回答其中的原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4568740|@kasperd的评论是正确的。假设你不是直接与数字相乘，而是与该数字的素数因子相乘。很多数字都会有2作为质数因子。在二进制中，这等于左移。通过交换性，我们可以先与2的素数因子相乘。这意味着我们只需要做一个左移。|4568741|查看二进制乘法规则时，1将导致特定数字位置的唯一情况是当两个操作数值都为1时。|4568742|因此，左移位的效果是，当进一步乘以结果时，1的最低位位置增加。|4568743|由于integer只包含最低阶位，因此当素数因数2在结果中经常出现时，它们都将被设置为0。|4568744|请注意，2的补码表示对于此分析并不重要，因为乘法结果的符号可以独立于结果数计算。这意味着如果值溢出并变为负数，则最低阶位将表示为1，但在乘法过程中，它们将再次被视为0。|4568745|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

Since many of the existing answer point to implementation details of Java and debug output, lets have a look at the math behind binary multiplication to really answer the why.

The comment of @kasperd goes in the right direction. Suppose you do not multiply directly with the number but with the prime factors of that number instead. Than a lot of numbers will have 2 as a prime factor. In binary this is equal to a left shift. By commutativity we can multiply with prime factors of 2 first. That means we just do a left shift.

When having a look at binary multiplication rules, the only case where a 1 will result in a specific digit position is when both operand values are one.

So the effect of a left shift is that the lowest bit position of a 1 when further multiplying the result is increased.

Since integer contains only the lowest order bits, they all will be set to 0 when the prime factor 2 is cotnained often enough in the result.

Note that two's complement representation is not of interest for this analysis, since the sign of the multiplication result can be computed independently from the resulting number. That means if the value overflows and becomes negative, the lowest order bits are represented as 1, but during multiplication they are treated again as being 0.

blocks|key|4568763|text|最终，计算溢出，最终溢出导致乘积为零；当product+==+-2147483648和i+==+42发生时就会发生这种情况。尝试使用此代码自己进行验证(或运行代码here)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4568764|import+java.math.BigInteger;

class+Ideone+{
++++public+static+void+main+(String[]+args)+throws+java.lang.Exception+{
++++++++System.out.println("Result:+"+%2B+(-2147483648+*+42));
++++}
}|code-block|syntax|javascript|4568765|一旦它为零，它当然会保持为零。下面的代码将产生更准确的结果(您可以运行代码here)：|4568766|import+java.math.BigInteger;

class+Ideone+{
++++public+static+void+main+(String[]+args)+throws+java.lang.Exception+{
++++++++BigInteger+p+=+BigInteger.valueOf(1);
++++++++BigInteger+start+=+BigInteger.valueOf(10);
++++++++BigInteger+end+=+BigInteger.valueOf(99);
++++++++for(BigInteger+i+=+start;+i.compareTo(end)+<+0;+i+=+i.add(BigInteger.ONE)){
++++++++++++p+=+p.multiply(i);
++++++++++++System.out.println("p:+"+%2B+p);
++++++++}
++++++++System.out.println("\nProduct:+"+%2B+p);
++++}
}|4568767|entityMap|0|LINK|mutability|MUTABLE|url|http://ideone.com/PGuFnc|1|http://ideone.com/n2t3Ni^0|K|M|17|7|29|4|0|0|0|11|4|1|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|M|3|N|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]]]

Eventually, the calculation overflows, and eventually that overflow leads to a product of zero; that happens when <code>product == -2147483648</code> and <code>i == 42</code>. Try this code out to verify it for yourself (or run the code <a href="http://ideone.com/PGuFnc">here</a>):

<pre><code>import java.math.BigInteger;

class Ideone {
 public static void main (String[] args) throws java.lang.Exception {
 System.out.println("Result: " + (-2147483648 * 42));
 }
}
</code></pre>

Once it's zero, it of course stays zero. Here's some code that will produce a more accurate result (you can run the code <a href="http://ideone.com/n2t3Ni">here</a>):

<pre><code>import java.math.BigInteger;

class Ideone {
 public static void main (String[] args) throws java.lang.Exception {
 BigInteger p = BigInteger.valueOf(1);
 BigInteger start = BigInteger.valueOf(10);
 BigInteger end = BigInteger.valueOf(99);
 for(BigInteger i = start; i.compareTo(end) &lt; 0; i = i.add(BigInteger.ONE)){
 p = p.multiply(i);
 System.out.println("p: " + p);
 }
 System.out.println("\nProduct: " + p);
 }
}
</code></pre>

blocks|key|4568801|text|这是因为整数溢出。当你将许多偶数相乘时，二进制数会得到很多尾随的零。当int的尾随零超过32个时，它会转到0。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4568802|为了帮助您可视化这一点，这里是在不会溢出的number类型上计算的十六进制乘法。看看尾随的零是如何慢慢增长的，并注意int是由最后8个十六进制数字组成的。乘以42+(0x2A)后，int的所有32位均为零！|4568803|+++++++++++++++++++++++++++++++++++++1+(int:+00000001)+*+0A+=
+++++++++++++++++++++++++++++++++++++A+(int:+0000000A)+*+0B+=
++++++++++++++++++++++++++++++++++++6E+(int:+0000006E)+*+0C+=
+++++++++++++++++++++++++++++++++++528+(int:+00000528)+*+0D+=
++++++++++++++++++++++++++++++++++4308+(int:+00004308)+*+0E+=
+++++++++++++++++++++++++++++++++3AA70+(int:+0003AA70)+*+0F+=
++++++++++++++++++++++++++++++++36FC90+(int:+0036FC90)+*+10+=
+++++++++++++++++++++++++++++++36FC900+(int:+036FC900)+*+11+=
++++++++++++++++++++++++++++++3A6C5900+(int:+3A6C5900)+*+12+=
+++++++++++++++++++++++++++++41B9E4200+(int:+1B9E4200)+*+13+=
++++++++++++++++++++++++++++4E0CBEE600+(int:+0CBEE600)+*+14+=
+++++++++++++++++++++++++++618FEE9F800+(int:+FEE9F800)+*+15+=
++++++++++++++++++++++++++800CE9315800+(int:+E9315800)+*+16+=
+++++++++++++++++++++++++B011C0A3D9000+(int:+0A3D9000)+*+17+=
++++++++++++++++++++++++FD1984EB87F000+(int:+EB87F000)+*+18+=
++++++++++++++++++++++17BA647614BE8000+(int:+14BE8000)+*+19+=
+++++++++++++++++++++25133CF88069A8000+(int:+069A8000)+*+1A+=
++++++++++++++++++++3C3F4313D0ABB10000+(int:+ABB10000)+*+1B+=
+++++++++++++++++++65AAC1317021BAB0000+(int:+1BAB0000)+*+1C+=
++++++++++++++++++B1EAD216843B06B40000+(int:+06B40000)+*+1D+=
++++++++++++++++142799CC8CFAAFC2640000+(int:+C2640000)+*+1E+=
+++++++++++++++25CA405F8856098C7B80000+(int:+C7B80000)+*+1F+=
++++++++++++++4937DCB91826B2802F480000+(int:+2F480000)+*+20+=
+++++++++++++926FB972304D65005E9000000+(int:+E9000000)+*+21+=
+++++++++++12E066E7B839FA050C309000000+(int:+09000000)+*+22+=
++++++++++281CDAAC677B334AB9E732000000+(int:+32000000)+*+23+=
+++++++++57BF1E59225D803376A9BD6000000+(int:+D6000000)+*+24+=
++++++++C56E04488D526073CAFDEA18000000+(int:+18000000)+*+25+=
++++++1C88E69E7C6CE7F0BC56B2D578000000+(int:+78000000)+*+26+=
+++++43C523B86782A6DBBF4DE8BAFD0000000+(int:+D0000000)+*+27+=
++++A53087117C4E76B7A24DE747C8B0000000+(int:+B0000000)+*+28+=
++19CF951ABB6C428CB15C2C23375B80000000+(int:+80000000)+*+29+=
+4223EE1480456A88867C311A3DDA780000000+(int:+80000000)+*+2A+=
AD9E50F5D0B637A6610600E4E25D7B00000000+(int:+00000000)|code-block|syntax|javascript|4568804|entityMap^0|Z|3|1H|1|0|1M|3|2I|3|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

It's because of integer overflow. When you multiply many even numbers together, the binary number gets a lot of trailing zeroes. When you have over 32 trailing zeroes for an <code>int</code>, it rolls over to <code>0</code>.

To help you visualize this, here are the multiplications in hex calculated on a number type that won't overflow. See how the trailing zeroes slowly grow, and note that an <code>int</code> is made up of the last 8 hex-digits. After multiplying by 42 (0x2A), all 32 bits of an <code>int</code> are zeroes!

<pre class="lang-none prettyprint-override"><code> 1 (int: 00000001) * 0A =
 A (int: 0000000A) * 0B =
 6E (int: 0000006E) * 0C =
 528 (int: 00000528) * 0D =
 4308 (int: 00004308) * 0E =
 3AA70 (int: 0003AA70) * 0F =
 36FC90 (int: 0036FC90) * 10 =
 36FC900 (int: 036FC900) * 11 =
 3A6C5900 (int: 3A6C5900) * 12 =
 41B9E4200 (int: 1B9E4200) * 13 =
 4E0CBEE600 (int: 0CBEE600) * 14 =
 618FEE9F800 (int: FEE9F800) * 15 =
 800CE9315800 (int: E9315800) * 16 =
 B011C0A3D9000 (int: 0A3D9000) * 17 =
 FD1984EB87F000 (int: EB87F000) * 18 =
 17BA647614BE8000 (int: 14BE8000) * 19 =
 25133CF88069A8000 (int: 069A8000) * 1A =
 3C3F4313D0ABB10000 (int: ABB10000) * 1B =
 65AAC1317021BAB0000 (int: 1BAB0000) * 1C =
 B1EAD216843B06B40000 (int: 06B40000) * 1D =
 142799CC8CFAAFC2640000 (int: C2640000) * 1E =
 25CA405F8856098C7B80000 (int: C7B80000) * 1F =
 4937DCB91826B2802F480000 (int: 2F480000) * 20 =
 926FB972304D65005E9000000 (int: E9000000) * 21 =
 12E066E7B839FA050C309000000 (int: 09000000) * 22 =
 281CDAAC677B334AB9E732000000 (int: 32000000) * 23 =
 57BF1E59225D803376A9BD6000000 (int: D6000000) * 24 =
 C56E04488D526073CAFDEA18000000 (int: 18000000) * 25 =
 1C88E69E7C6CE7F0BC56B2D578000000 (int: 78000000) * 26 =
 43C523B86782A6DBBF4DE8BAFD0000000 (int: D0000000) * 27 =
 A53087117C4E76B7A24DE747C8B0000000 (int: B0000000) * 28 =
 19CF951ABB6C428CB15C2C23375B80000000 (int: 80000000) * 29 =
 4223EE1480456A88867C311A3DDA780000000 (int: 80000000) * 2A =
AD9E50F5D0B637A6610600E4E25D7B00000000 (int: 00000000)
</code></pre>

blocks|key|62671|text|它是一个整数溢出。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|62672|int数据类型为4字节或32位。因此，此数据类型中不能存储大于2%5E(32+-+1)+-1+(2,147,483,647)的数字。您的数值将不正确。|62673|对于非常大的数字，您需要导入并使用类java.math.BigInteger:|offset|length|style|CODE|62674|BigInteger+product+=+BigInteger.ONE;
for+(long+i+=+10;+i+<+99;+i%2B%2B)+
++++product+=+product.multiply(BigInteger.valueOf(i));
System.out.println(product.toString());|code-block|syntax|javascript|62675|注意:对于对于int数据类型来说仍然太大，但小到足以容纳8个字节(绝对值小于或等于2%5E(64+-+1)+-+1)的数值，您可能应该使用long原语。|62676|HackerRank的实践问题(www.hackerrank.com)，例如算法实践部分(https://www.hackerrank.com/domains/algorithms/warmup)，包括一些非常好的大量问题，这些问题提供了关于如何考虑要使用的适当数据类型的良好实践。|62677|entityMap|0|LINK|mutability|MUTABLE|url|https://www.hackerrank.com/domains/algorithms/warmup^0|0|0|I|L|0|0|1V|4|0|19|1G|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@$F|13|G|14|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|15|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|16|8|@$F|17|G|18|H|I]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@$F|1A|G|1B|1|1C]]|A|$]]|$1|S|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

It is an integer overflow.

The int data type is 4 bytes, or 32 bits. Therefore, numbers larger than 2^(32 - 1) - 1 (2,147,483,647) cannot be stored in this data type. Your numerical values will be incorrect.

For very large numbers, you will want to import and use the class <code>java.math.BigInteger:</code>

<pre><code>BigInteger product = BigInteger.ONE;
for (long i = 10; i &lt; 99; i++) 
 product = product.multiply(BigInteger.valueOf(i));
System.out.println(product.toString());
</code></pre>

NOTE: For numerical values that are still too large for the int data type, but small enough to fit within 8 bytes (absolute value less than or equal to 2^(64 - 1) - 1), you should probably use the <code>long</code> primitive. 

HackerRank's practice problems (www.hackerrank.com), such as the Algorithms practice section, (<a href="https://www.hackerrank.com/domains/algorithms/warmup" rel="nofollow">https://www.hackerrank.com/domains/algorithms/warmup</a>) include some very good large-number questions that give good practice about how to think about the appropriate data type to use.

The following block of codes gives the output as 0.
<pre><code>public class HelloWorld{

 public static void main(String []args){
 int product = 1;
 for (int i = 10; i &lt;= 99; i++) {
 product *= i;
 }
 System.out.println(product);
 }
}
</code></pre>
Please can somebody explain why this happens?

Why does Java think that the product of all numbers from 10 to 99 is 0?

Java

下面的代码块给出的输出为0。public class HelloWorld{ public static void main(String []args){ int product = 1; for (int i = 10; i <= 99; i++) { pro...

问为什么Java认为从10到99的所有数字的乘积都是0？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么Java认为从10到99的所有数字的乘积都是0？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么Java认为从10到99的所有数字的乘积都是0？
EN