blocks|key|1179352|text|BigDecimal是一种精确的数字表示方式。Double具有一定的精度。使用不同幅度的倍增(例如d1=1000.0和d2=0.001)可能会导致0.001在求和时一起下降，因为幅度的差异如此之大。如果使用BigDecimal，这种情况就不会发生。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1179353|BigDecimal的缺点是速度较慢，而且以这种方式编写算法会有点困难(因为%2B+-+*和/没有过载)。|1179354|如果你和钱打交道，或者精确度是必须的，那就使用BigDecimal。否则，Doubles往往就足够好了。|1179355|我确实推荐阅读BigDecimal的javadoc，因为它们比我在这里更好地解释了事情:)|1179356|entityMap|0|LINK|mutability|MUTABLE|url|http://download.oracle.com/javase/1.5.0/docs/api/java/math/BigDecimal.html^0|0|A|N|6|1D|9|1N|8|21|5|2V|A|0|0|A|12|1|14|1|16|1|18|1|0|N|A|11|7|0|7|A|I|7|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@$9|1P|A|1Q|1|1R]]|E|$]]|$1|L|3|-4|5|6|7|1S|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|S]]]]

A <code>BigDecimal</code> is an exact way of representing numbers. A <code>Double</code> has a certain precision. Working with doubles of various magnitudes (say <code>d1=1000.0</code> and <code>d2=0.001</code>) could result in the <code>0.001</code> being dropped alltogether when summing as the difference in magnitude is so large. With <code>BigDecimal</code> this would not happen.

The disadvantage of <code>BigDecimal</code> is that it's slower, and it's a bit more difficult to program algorithms that way (due to <code>+</code> <code>-</code> <code>*</code> and <code>/</code> not being overloaded).

If you are dealing with money, or precision is a must, use <code>BigDecimal</code>. Otherwise <code>Doubles</code> tend to be good enough.

I do recommend reading the <a href="http://download.oracle.com/javase/1.5.0/docs/api/java/math/BigDecimal.html" rel="noreferrer">javadoc</a> of <code>BigDecimal</code> as they do explain things better than I do here :)

blocks|key|1179427|text|BigDecimal是Oracle的任意精度数值库。BigDecimal是Java语言的一部分，对于从金融到科学的各种应用程序都很有用(这就是某种意义上的am)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1179428|在某些计算中使用doubles并没有错。但是，假设您想要计算Math.Pi+*+Math.Pi+/+6，即Riemann+Zeta函数的实参为2的值(我目前正在进行的一个项目)。浮点除法给你带来了一个痛苦的舍入误差问题。|1179429|另一方面，BigDecimal包括许多用于计算任意精度的表达式的选项。下面的Oracle文档中描述的add、multiply和divide方法在BigDecimal+Java+World中“取代”了%2B、*和/：|1179430|http://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html|offset|length|1179431|compareTo方法在while和for循环中特别有用。|1179432|但是，在使用BigDecimal的构造函数时要小心。string构造器在许多情况下都非常有用。例如，代码|1179433|BigDecimal+onethird+=新的BigDecimal("0.33333333333")；|1179434|使用1/3的字符串表示形式以指定的准确度表示无限重复的数字。舍入错误很可能是在JVM内部很深的某个地方，以至于舍入错误不会干扰您的大多数实际计算。然而，根据我的个人经验，我已经看到了四舍五入的悄悄上升。从setScale文档中可以看出，在这些方面，Oracle方法很重要。|1179435|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|1U|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@$H|12|I|13|1|14]]|A|$]]|$1|J|3|K|5|6|7|15|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|16|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|17|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|18|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|G]]]]

BigDecimal is Oracle's arbitrary-precision numerical library. BigDecimal is part of the Java language and is useful for a variety of applications ranging from the financial to the scientific (that's where sort of am).

There's nothing wrong with using doubles for certain calculations. Suppose, however, you wanted to calculate Math.Pi * Math.Pi / 6, that is, the value of the Riemann Zeta Function for a real argument of two (a project I'm currently working on). Floating-point division presents you with a painful problem of rounding error.

BigDecimal, on the other hand, includes many options for calculating expressions to arbitrary precision. The add, multiply, and divide methods as described in the Oracle documentation below "take the place" of +, *, and / in BigDecimal Java World:

<a href="http://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html" rel="nofollow noreferrer">http://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html</a>

The compareTo method is especially useful in while and for loops.

Be careful, however, in your use of constructors for BigDecimal. The string constructor is very useful in many cases. For instance, the code

BigDecimal onethird = new BigDecimal("0.33333333333");

utilizes a string representation of 1/3 to represent that infinitely-repeating number to a specified degree of accuracy. The round-off error is most likely somewhere so deep inside the JVM that the round-off errors won't disturb most of your practical calculations. I have, from personal experience, seen round-off creep up, however. The setScale method is important in these regards, as can be seen from the Oracle documentation.

blocks|key|1179501|text|我的英语不好，所以我在这里只写一个简单的例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1179502|double+a+=+0.02;
double+b+=+0.03;
double+c+=+b+-+a;
System.out.println(c);

BigDecimal+_a+=+new+BigDecimal("0.02");
BigDecimal+_b+=+new+BigDecimal("0.03");
BigDecimal+_c+=+_b.subtract(_a);
System.out.println(_c);|code-block|syntax|javascript|1179503|程序输出：|1179504|0.009999999999999998
0.01|1179505|还有人想用double吗？;)|1179506|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

My English is not good so I'll just write a simple example here.
<pre class="lang-java prettyprint-override"><code>double a = 0.02;
double b = 0.03;
double c = b - a;
System.out.println(c);

BigDecimal _a = new BigDecimal(&quot;0.02&quot;);
BigDecimal _b = new BigDecimal(&quot;0.03&quot;);
BigDecimal _c = _b.subtract(_a);
System.out.println(_c);
</code></pre>
Program output:
<pre><code>0.009999999999999998
0.01
</code></pre>
Does anyone still want to use double? ;)

blocks|key|1179583|text|如果你写一个像1+/+7这样的小数值作为十进制值，你会得到|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1179584|1/7+=+0.142857142857142857142857142857142857142857...|code-block|syntax|javascript|1179585|具有无限序列的142857。由于您只能写入有限数量的数字，因此不可避免地会引入舍入(或截断)错误。|1179586|像1/10或1/100这样的用带小数部分的二进制数表示的数字在小数点后也有无限位数：|1179587|1/10+=+binary+0.0001100110011001100110011001100110...|1179588|Doubles将值存储为二进制，因此可能仅通过将十进制数转换为二进制数而引入错误，甚至不进行任何算术。|1179589|另一方面，十进制数字(如BigDecimal)按原样存储每个十进制数字(二进制编码，但每个十进制数字都是独立的)。这意味着在一般意义上，decimal类型并不比二进制浮点或定点类型更精确(即，它无法在不损失精度的情况下存储1/7+)，但对于小数位数有限的数字来说，它更准确，这通常是货币计算的情况。|1179590|Java的BigDecimal有一个额外的优点，它可以在小数点两侧有任意(但有限的)位数，只受可用内存的限制。|1179591|entityMap^0|7|5|0|0|7|6|0|1|4|6|5|0|0|0|7|0|C|A|33|3|0|5|A|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|X|$]]

If you write down a fractional value like <code>1 / 7</code> as decimal value you get
<pre><code>1/7 = 0.142857142857142857142857142857142857142857...
</code></pre>
with an infinite sequence of <code>142857</code>. Since you can only write a finite number of digits you will inevitably introduce a rounding (or truncation) error.
Numbers like <code>1/10</code> or <code>1/100</code> expressed as binary numbers with a fractional part also have an infinite number of digits after the decimal point:
<pre><code>1/10 = binary 0.0001100110011001100110011001100110...
</code></pre>
<code>Doubles</code> store values as binary and therefore might introduce an error solely by converting a decimal number to a binary number, without even doing any arithmetic.
Decimal numbers (like <code>BigDecimal</code>), on the other hand, store each decimal digit as is (binary coded, but each decimal on its own). This means that a decimal type is not more precise than a binary floating point or fixed point type in a general sense (i.e. it cannot store <code>1/7</code> without loss of precision), but it is more accurate for numbers that have a finite number of decimal digits as is often the case for money calculations.
Java's <code>BigDecimal</code> has the additional advantage that it can have an arbitrary (but finite) number of digits on both sides of the decimal point, limited only by the available memory.

blocks|key|965437|text|如果你正在处理计算，有关于你应该如何计算以及你应该使用什么精度的规则。如果你不能做到这一点，你将做一些非法的事情。唯一真正的原因是小数情况的比特表示不精确。正如Basil简单地说，一个例子是最好的解释。为了补充他的例子，下面是发生的事情：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|965438|static+void+theDoubleProblem1()+{
++++double+d1+=+0.3;
++++double+d2+=+0.2;
++++System.out.println("Double:\t+0,3+-+0,2+=+"+%2B+(d1+-+d2));

++++float+f1+=+0.3f;
++++float+f2+=+0.2f;
++++System.out.println("Float:\t+0,3+-+0,2+=+"+%2B+(f1+-+f2));

++++BigDecimal+bd1+=+new+BigDecimal("0.3");
++++BigDecimal+bd2+=+new+BigDecimal("0.2");
++++System.out.println("BigDec:\t+0,3+-+0,2+=+"+%2B+(bd1.subtract(bd2)));
}|code-block|syntax|javascript|965439|输出：|965440|Double:++0,3+-+0,2+=+0.09999999999999998
Float:+++0,3+-+0,2+=+0.10000001
BigDec:++0,3+-+0,2+=+0.1|965441|我们也有：|965442|static+void+theDoubleProblem2()+{
++++double+d1+=+10;
++++double+d2+=+3;
++++System.out.println("Double:\t+10+/+3+=+"+%2B+(d1+/+d2));

++++float+f1+=+10f;
++++float+f2+=+3f;
++++System.out.println("Float:\t+10+/+3+=+"+%2B+(f1+/+f2));

++++//+Exception!+
++++BigDecimal+bd3+=+new+BigDecimal("10");
++++BigDecimal+bd4+=+new+BigDecimal("3");
++++System.out.println("BigDec:\t+10+/+3+=+"+%2B+(bd3.divide(bd4)));
}|965443|为我们提供以下输出：|965444|Double:++10+/+3+=+3.3333333333333335
Float:+++10+/+3+=+3.3333333
Exception+in+thread+"main"+java.lang.ArithmeticException:+Non-terminating+decimal+expansion|965445|但是：|965446|static+void+theDoubleProblem2()+{
++++BigDecimal+bd3+=+new+BigDecimal("10");
++++BigDecimal+bd4+=+new+BigDecimal("3");
++++System.out.println("BigDec:\t+10+/+3+=+"+%2B+(bd3.divide(bd4,+4,+BigDecimal.ROUND_HALF_UP)));
}|965447|输出如下：|965448|BigDec:++10+/+3+=+3.3333+|965449|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

If you are dealing with calculation, there are laws on how you should calculate and what precision you should use. If you fail that you will be doing something illegal. 
The only real reason is that the bit representation of decimal cases are not precise. As Basil simply put, an example is the best explanation. Just to complement his example, here's what happens: 

<pre><code>static void theDoubleProblem1() {
 double d1 = 0.3;
 double d2 = 0.2;
 System.out.println("Double:\t 0,3 - 0,2 = " + (d1 - d2));

 float f1 = 0.3f;
 float f2 = 0.2f;
 System.out.println("Float:\t 0,3 - 0,2 = " + (f1 - f2));

 BigDecimal bd1 = new BigDecimal("0.3");
 BigDecimal bd2 = new BigDecimal("0.2");
 System.out.println("BigDec:\t 0,3 - 0,2 = " + (bd1.subtract(bd2)));
}
</code></pre>

Output: 

<pre><code>Double: 0,3 - 0,2 = 0.09999999999999998
Float: 0,3 - 0,2 = 0.10000001
BigDec: 0,3 - 0,2 = 0.1
</code></pre>

Also we have that: 

<pre><code>static void theDoubleProblem2() {
 double d1 = 10;
 double d2 = 3;
 System.out.println("Double:\t 10 / 3 = " + (d1 / d2));

 float f1 = 10f;
 float f2 = 3f;
 System.out.println("Float:\t 10 / 3 = " + (f1 / f2));

 // Exception! 
 BigDecimal bd3 = new BigDecimal("10");
 BigDecimal bd4 = new BigDecimal("3");
 System.out.println("BigDec:\t 10 / 3 = " + (bd3.divide(bd4)));
}
</code></pre>

Gives us the output: 

<pre><code>Double: 10 / 3 = 3.3333333333333335
Float: 10 / 3 = 3.3333333
Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion
</code></pre>

But: 

<pre><code>static void theDoubleProblem2() {
 BigDecimal bd3 = new BigDecimal("10");
 BigDecimal bd4 = new BigDecimal("3");
 System.out.println("BigDec:\t 10 / 3 = " + (bd3.divide(bd4, 4, BigDecimal.ROUND_HALF_UP)));
}
</code></pre>

Has the output: 

<pre><code>BigDec: 10 / 3 = 3.3333 
</code></pre>

I have to calculate some floating point variables and my colleague suggest me to use <code>BigDecimal</code> instead of <code>double</code> since it will be more precise. But I want to know what it is and how to make most out of <code>BigDecimal</code>?

Double vs. BigDecimal?

Java

我必须计算一些浮点变量，我的同事建议我使用BigDecimal而不是double，因为它会更精确。但是我想知道它是什么，以及如何最大限度地利用BigDecimal

问Double vs. BigDecimal？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Double vs. BigDecimal？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Double vs. BigDecimal？
EN