blocks|key|1911032|text|你真正想要的是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1911033|new+BigDecimal("0.1")
+.add(new+BigDecimal("0.1"))
+.add(new+BigDecimal("0.1"));|code-block|syntax|javascript|1911034|new+BigDecimal(double)构造函数获得了double的所有不精确度，所以当您说0.1时，您已经引入了舍入误差。使用String构造函数可以避免与通过double进行操作相关的舍入错误。|offset|length|style|CODE|1911035|entityMap^0|0|0|0|M|T|6|1C|3|1U|6|2B|6|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|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$]]

What you actually want is

<pre><code>new BigDecimal("0.1")
 .add(new BigDecimal("0.1"))
 .add(new BigDecimal("0.1"));
</code></pre>

The <code>new BigDecimal(double)</code> constructor gets all the imprecision of the <code>double</code>, so by the time you've said <code>0.1</code>, you've already introduced the rounding error. Using the <code>String</code> constructor avoids the rounding error associated with going via the <code>double</code>.

blocks|key|5365182|text|First++never+，千万不要使用BigDecimal的双构造函数。这在某些情况下可能是正确的，但大多数情况下不是。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|5365183|如果可以控制输入，请使用前面提出的BigDecimal字符串构造函数。这样你就能得到你想要的东西。如果您已经有了double+(毕竟可能会发生)，那么不要使用double构造函数，而要使用静态valueOf方法。这有一个很好的优势，那就是我们得到了double的规范表示，这至少减轻了问题。而且结果通常更直观。|CODE|5365184|entityMap^0|6|7|0|2O|7|0^^$0|@$1|2|3|4|5|6|7|K|8|@$9|L|A|M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|N|8|@$9|O|A|P|B|H]]|D|@]|E|$]]|$1|I|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|J|$]]

First never, never use the double constructor of BigDecimal. It may be the right thing in a few situations but mostly it isn't

If you can control your input use the BigDecimal String constructor as was already proposed. That way you get exactly what you want. If you already have a double (can happen after all), don't use the double constructor but instead the static <code>valueOf</code> method. That has the nice advantage that we get the cannonical representation of the double which mitigates the problem at least.. and the result is usually much more intuitive.

blocks|key|1324833|text|这不是Java的问题，而是一般计算机的问题。核心问题在于从十进制格式(人的格式)到二进制格式(计算机格式)的转换。有些十进制格式的数字在没有无限重复小数的情况下不能用二进制格式表示。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1324834|例如，0.01001100小数点等于0.01001100...但是一台计算机有一个有限的“槽”(位)来保存一个数字，所以它不能保存整个无穷大的表示。例如，它只节省了0.01001100110011001100。但以十进制表示的数字不再是0.3，而是0.30000000000000004。|1324835|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

This is not a problem of Java, but rather a problem of computers generally. The core problem lies in the conversion from decimal format (human format) to binary format (computer format). Some numbers in decimal format are not representable in binary format without infinite repeating decimals.

For example, 0.3 decimal is 0.01001100... binary But a computer has a limited "slots" (bits) to save a number, so it cannot save all the whole infinite representation. It saves only
0.01001100110011001100 (for example). But that number in decimal is no longer 0.3, but 0.30000000000000004 instead.

blocks|key|1916263|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1916264|BigDecimal+sum+=+new+BigDecimal(0.1).add(new+BigDecimal(0.1)).add(new+BigDecimal(0.1));|code-block|syntax|javascript|1916265|编辑:实际上，查看Javadoc，这将会有与原始版本相同的问题。构造函数BigDecimal(double)将生成一个与0.1的精确浮点表示形式相对应的BigDecimal，该值并不完全等于0.1。|offset|length|style|CODE|1916266|然而，这给出了确切的结果，因为整数总是可以用浮点表示精确地表示：|1916267|BigDecimal+one+=+new+BigDecimal(1);
BigDecimal+oneTenth+=+one.divide(new+BigDecimal(10));

BigDecimal+sum+=+oneTenth.add(oneTenth).add(oneTenth);|1916268|entityMap^0|0|0|10|I|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Try this:

<pre><code>BigDecimal sum = new BigDecimal(0.1).add(new BigDecimal(0.1)).add(new BigDecimal(0.1));
</code></pre>

EDIT: Actually, looking over the Javadoc, this will have the same problem as the original. The constructor <code>BigDecimal(double)</code> will make a BigDecimal corresponding to the exact floating-point representation of 0.1, which is not exactly equal to 0.1.

This, however, gives the exact result, since integers CAN always be expressed exactly in floating-point representation:

<pre><code>BigDecimal one = new BigDecimal(1);
BigDecimal oneTenth = one.divide(new BigDecimal(10));

BigDecimal sum = oneTenth.add(oneTenth).add(oneTenth);
</code></pre>

blocks|key|1324997|text|你的问题是0.1用一个稍高的数字来表示，例如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1324998|System.out.println(new+BigDecimal(0.1));|code-block|syntax|javascript|1324999|打印|1325000|0.1000000000000000055511151231257827021181583404541015625|1325001|Double.toString()考虑到了这个表示错误，所以您看不到它。|1325002|类似地，0.3由一个比实际值稍低的值表示。|1325003|0.299999999999999988897769753748434595763683319091796875|1325004|如果将0.1的表示值乘以3，则得到的不是0.3的表示值，而是更高一点的值|1325005|0.3000000000000000166533453693773481063544750213623046875|1325006|这不仅是表示误差，而且是由操作引起的舍入误差。这超出了Double.toString()所能纠正的范围，因此您可以看到舍入误差。|1325007|这个故事的寓意是，如果您使用float或double，也可以适当地绕过解决方案。|offset|length|style|CODE|1325008|double+d+=+0.1+%2B+0.1+%2B+0.1;
System.out.println(d);
double+d2+=+(long)(d+*+1e6+%2B+0.5)+/+1e6;+//+round+to+6+decimal+places.
System.out.println(d2);|1325009|1325010|0.30000000000000004
0.3|1325011|entityMap^0|0|0|0|0|0|0|0|0|0|0|E|5|K|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1B|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1D|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1E|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1I|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1J|8|@$Y|1K|Z|1L|10|11]|$Y|1M|Z|1N|10|11]]|9|@]|A|$]]|$1|12|3|13|5|D|7|1O|8|@]|9|@]|A|$E|F]]|$1|14|3|H|5|6|7|1P|8|@]|9|@]|A|$]]|$1|15|3|16|5|D|7|1Q|8|@]|9|@]|A|$E|F]]|$1|17|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]]|18|$]]

The problem you have is that 0.1 is represented with a slightly higher number e.g.

<pre><code>System.out.println(new BigDecimal(0.1));
</code></pre>

prints

<pre><code>0.1000000000000000055511151231257827021181583404541015625
</code></pre>

The Double.toString() takes into account this representation error so you don't see it.

Similarly 0.3 is represented by a value slightly lower than it really is.

<pre><code>0.299999999999999988897769753748434595763683319091796875
</code></pre>

If you multiply the represented value of 0.1 by 3 you don't get the represented value for 0.3, you instead get something a little higher

<pre><code>0.3000000000000000166533453693773481063544750213623046875
</code></pre>

This is not just a representation error but also a rounding error caused by the operations. This is more than the Double.toString() will correct and so you see the rounding error.

The moral of the story, if you use <code>float</code> or <code>double</code> also round the solution appropriately.

<pre><code>double d = 0.1 + 0.1 + 0.1;
System.out.println(d);
double d2 = (long)(d * 1e6 + 0.5) / 1e6; // round to 6 decimal places.
System.out.println(d2);
</code></pre>

prints

<pre><code>0.30000000000000004
0.3
</code></pre>

I know the following behavior is an old problem, but still I don't understand.

<pre><code>System.out.println(0.1 + 0.1 + 0.1); 
</code></pre>

Or even though I use <code>BigDecimal</code>

<pre><code>System.out.println(new BigDecimal(0.1).doubleValue()
 + new BigDecimal(0.1).doubleValue()
 + new BigDecimal(0.1).doubleValue());
</code></pre>

Why this result is: <code>0.30000000000000004</code> instead of: <code>0.3</code>?

How can I solve this?

Java BigDecimal precision problems

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

System.out.println(0.1 + 0.1 + 0.1);    或者即使我使用BigDecimalSystem.out.println(new BigDecimal(0.1).doubleValue()    + new BigDecimal(0.1).doubleValue()    + new BigDecimal(0.1).doubleValue());我该如何解决这个问题呢

问Java BigDecimal精度问题
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java BigDecimal精度问题EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java BigDecimal精度问题
EN