blocks|key|1009434|text|这是由计算机存储浮点数的方式引起的。他们并不完全这样做。作为一名程序员，您应该阅读this+floating-point+guide以熟悉处理浮点数的各种考验。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1009435|entityMap|0|LINK|mutability|MUTABLE|url|http://floating-point-gui.de/^0|15|P|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

This is caused by the way computers store floating-point numbers. They don't do so exactly. As a programmer, you should read <a href="http://floating-point-gui.de/" rel="noreferrer">this floating-point guide</a> to familiarize yourself with the trials and tribulations of handling floating-point numbers.

blocks|key|794992|text|不是，因为Java+floating+point+types+(实际上是所有浮点类型)是大小和精度之间的折衷。虽然它们对于许多任务非常有用，但如果您需要任意精度，则应该使用BigDecimal。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|794993|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3^0|2E|A|5|P|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

No, as <a href="http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3" rel="nofollow">Java floating point types</a> (indeed all floating point types) are a trade-off between size and precision. While they're very useful for a lot of tasks, if you need arbitrary precision, you should use <code>BigDecimal</code>.

blocks|key|795062|text|如果您使用double或float，您应该使用舍入或期望看到一些舍入误差。如果不能做到这一点，请使用BigDecimal。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|795063|您的问题是0.1不是一个精确的表示，通过执行两次计算，您正在加剧该错误。|795064|但是，100可以准确地表示出来，所以请尝试：|795065|double+x+=+1234;
x+/=+100;
System.out.println(x);|code-block|syntax|javascript|795066|打印的内容：|795067|12.34|795068|这之所以有效，是因为Double.toString(d)代表您执行了少量的舍入，但并不是很多。如果你想知道如果没有四舍五入，它会是什么样子：|795069|System.out.println(new+BigDecimal(0.1));
System.out.println(new+BigDecimal(x));|795070|打印：|795071|0.100000000000000005551115123125782702118158340454101562
12.339999999999999857891452847979962825775146484375|795072|简而言之，对于浮点数中的合理答案，取整是不可避免的，无论你是否显式地这样做。|795073|795074|注意:当涉及到舍入误差时，x+/+100和x+*+0.01并不完全相同。这是因为第一个表达式的舍入误差取决于x的值，而第二个表达式中的0.01具有固定的舍入误差。|795075|for(int+i=0;i<200;i%2B%2B)+{
++++double+d1+=+(double)+i+/+100;
++++double+d2+=+i+*+0.01;
++++if+(d1+!=+d2)
++++++++System.out.println(d1+%2B+"+!=+"%2Bd2);
}|795076|打印|795077|0.35+!=+0.35000000000000003
0.41+!=+0.41000000000000003
0.47+!=+0.47000000000000003
0.57+!=+0.5700000000000001
0.69+!=+0.6900000000000001
0.7+!=+0.7000000000000001
0.82+!=+0.8200000000000001
0.83+!=+0.8300000000000001
0.94+!=+0.9400000000000001
0.95+!=+0.9500000000000001
1.13+!=+1.1300000000000001
1.14+!=+1.1400000000000001
1.15+!=+1.1500000000000001
1.38+!=+1.3800000000000001
1.39+!=+1.3900000000000001
1.4+!=+1.4000000000000001
1.63+!=+1.6300000000000001
1.64+!=+1.6400000000000001
1.65+!=+1.6500000000000001
1.66+!=+1.6600000000000001
1.88+!=+1.8800000000000001
1.89+!=+1.8900000000000001
1.9+!=+1.9000000000000001
1.91+!=+1.9100000000000001|795078|注:这与系统(或电源)中的随机性无关。这是由于表示错误造成的，每次都会产生相同的结果。double的精度是有限的，并且是以2为基数而不是以10为基数，因此可以用十进制精确表示的数字通常不能精确地用基数2表示。|795079|entityMap^0|5|6|C|5|1E|A|0|0|0|0|0|0|A|I|0|0|0|0|0|0|D|7|L|8|1V|4|0|0|0|0|17|6|0^^$0|@$1|2|3|4|5|6|7|1F|8|@$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1M|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1N|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1O|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1P|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1Q|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|U|3|V|5|L|7|1U|8|@]|D|@]|E|$M|N]]|$1|W|3|X|5|6|7|1V|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|L|7|1W|8|@]|D|@]|E|$M|N]]|$1|10|3|11|5|6|7|1X|8|@]|D|@]|E|$]]|$1|12|3|-4|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|13|3|14|5|6|7|1Z|8|@$9|20|A|21|B|C]|$9|22|A|23|B|C]|$9|24|A|25|B|C]]|D|@]|E|$]]|$1|15|3|16|5|L|7|26|8|@]|D|@]|E|$M|N]]|$1|17|3|18|5|6|7|27|8|@]|D|@]|E|$]]|$1|19|3|1A|5|L|7|28|8|@]|D|@]|E|$M|N]]|$1|1B|3|1C|5|6|7|29|8|@$9|2A|A|2B|B|C]]|D|@]|E|$]]|$1|1D|3|-4|5|6|7|2C|8|@]|D|@]|E|$]]]|1E|$]]

If you use <code>double</code> or <code>float</code>, you should use rounding or expect to see some rounding errors. If you can't do this, use <code>BigDecimal</code>.
The problem you have is that 0.1 is not an exact representation, and by performing the calculation twice, you are compounding that error.
However, 100 can be represented accurately, so try:
<pre><code>double x = 1234;
x /= 100;
System.out.println(x);
</code></pre>
which prints:
<pre><code>12.34
</code></pre>
This works because <code>Double.toString(d)</code> performs a small amount of rounding on your behalf, but it is not much. If you are wondering what it might look like without rounding:
<pre><code>System.out.println(new BigDecimal(0.1));
System.out.println(new BigDecimal(x));
</code></pre>
prints:
<pre><code>0.100000000000000005551115123125782702118158340454101562
12.339999999999999857891452847979962825775146484375
</code></pre>
In short, rounding is unavoidable for sensible answers in floating point whether you are doing this explicitly or not.
<hr />
Note: <code>x / 100</code> and <code>x * 0.01</code> are not exactly the same when it comes to rounding error. This is because the round error for the first expression depends on the values of x, whereas the <code>0.01</code> in the second has a fixed round error.
<pre><code>for(int i=0;i&lt;200;i++) {
 double d1 = (double) i / 100;
 double d2 = i * 0.01;
 if (d1 != d2)
 System.out.println(d1 + &quot; != &quot;+d2);
}
</code></pre>
prints
<pre><code>0.35 != 0.35000000000000003
0.41 != 0.41000000000000003
0.47 != 0.47000000000000003
0.57 != 0.5700000000000001
0.69 != 0.6900000000000001
0.7 != 0.7000000000000001
0.82 != 0.8200000000000001
0.83 != 0.8300000000000001
0.94 != 0.9400000000000001
0.95 != 0.9500000000000001
1.13 != 1.1300000000000001
1.14 != 1.1400000000000001
1.15 != 1.1500000000000001
1.38 != 1.3800000000000001
1.39 != 1.3900000000000001
1.4 != 1.4000000000000001
1.63 != 1.6300000000000001
1.64 != 1.6400000000000001
1.65 != 1.6500000000000001
1.66 != 1.6600000000000001
1.88 != 1.8800000000000001
1.89 != 1.8900000000000001
1.9 != 1.9000000000000001
1.91 != 1.9100000000000001
</code></pre>
NOTE: This has nothing to do with randomness in your system (or your power supply). This is due to a representation error, which will produce the same outcome every time. The precision of <code>double</code> is limited and in base 2 rather than base 10, so numbers which can be precisely represented in decimal often cann't be precisely represented in base 2.

blocks|key|795193|text|是的，有。对于每个重复操作，您可能会损失精度，但每个操作的精确度都不同，可以通过选择正确的操作顺序来最小化。例如，当对一组数字进行乘法时，最好在乘法之前按指数对集合进行排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|795194|任何一本关于数字处理的好书都描述了这一点。例如：http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html|offset|length|795195|回答你的问题：|795196|使用除法而不是乘法，这样你就可以得到正确的结果。|795197|double+x+=+1234;
for(int+i=1;i<=2;i%2B%2B)
{
++x+=++x+/+10.0;
}
System.out.println(x);|code-block|syntax|javascript|795198|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html^0|0|O|1Q|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Yes, there is. With each double operation you may lose accuracy but the amount of accuracy differs for each operation and can be minimized by choosing the right sequence of operations. For example when multiplying set of numbers, it is best to sort set by exponent before multiplying. 

Any decent book on number crunching describes this. For example:
<a href="http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html" rel="nofollow noreferrer">http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html</a>

And to answer your question: 

Use divide instead of multiply, this way you get correct result.

<pre><code>double x = 1234;
for(int i=1;i&lt;=2;i++)
{
 x = x / 10.0;
}
System.out.println(x);
</code></pre>

blocks|key|795252|text|在金融软件中，使用整数表示便士是很常见的。在学校，我们被教导如何使用定点而不是浮点，但这通常是2的幂。以整数形式存储便士也可以称为“定点”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|795253|int+i=1234;
printf("%25d.%2502d\r\n",i/100,i%25100);|code-block|syntax|javascript|795254|在课堂上，我们通常被问到什么数字可以精确地表示在基数中。|795255|对于base=p1%5En1*p2%5En2..。您可以表示任意N，其中N=n*p1%5Em1*p2%5Em2。|offset|length|style|CODE|795256|让base=14=2%5E1*7%5E1..。您可以表示1/7+1/14+1/28+1/49，但不能表示1/3|795257|我知道财务软件--我把Ticketmaster的财务报表从VAX+asm转换成PASCAL。他们有自己的formatln()，带有便士代码。转换的原因是32位整数不再足够。%2B/-+20亿便士相当于2000万美元，这笔钱已经溢出到世界杯或奥运会上了，我忘了。|795258|我发过誓要保守秘密。哦，好吧。在学术界，如果它是好的，你就发表；在工业界，你要保守秘密。|795259|entityMap^0|0|0|0|2|G|0|1|F|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@$K|13|L|14|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

In financial software it is common to use integers for pennies. In school, we were taught how to use fixed-point instead of floating, but that is usually powers of two. Storing pennies in integers might be called "fixed point" as well.

<pre><code>int i=1234;
printf("%d.%02d\r\n",i/100,i%100);
</code></pre>

In class, we were asked in general what numbers can be exactly represented in a base.

For <code>base=p1^n1*p2^n2</code>... you can represent any N where N=n*p1^m1*p2^m2.

Let <code>base=14=2^1*7^1</code>... you can represent 1/7 1/14 1/28 1/49 but not 1/3

I know about financial software -- I converted Ticketmaster's financial reports from VAX asm to PASCAL. They had their own formatln() with codes for pennies. The reason for the conversion was 32 bit integers were no longer enough. +/- 2 billion pennies is $20 million and that overflowed for the World Cup or Olympics, I forgot. 

I was sworn to secrecy. Oh well. In academea, if it's good you publish; in industry, you keep it secret.

blocks|key|795302|text|您可以尝试整数表示法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|795303|int+i+=1234;
int+q+=+i+/100;
int+r+=+i+%25+100;

System.out.printf("%25d.%2502d",q,+r);|code-block|syntax|javascript|795304|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

you can try integer number representation

<pre><code>int i =1234;
int q = i /100;
int r = i % 100;

System.out.printf("%d.%02d",q, r);
</code></pre>

So I have a double set to equal 1234, I want to move a decimal place over to make it 12.34

So to do this I multiply .1 to 1234 two times, kinda like this

<pre><code>double x = 1234;
for(int i=1;i&lt;=2;i++)
{
 x = x*.1;
}
System.out.println(x);
</code></pre>

This will print the result, "12.340000000000002"

Is there a way, without simply formatting it to two decimal places, to have the double store 12.34 correctly?

Moving decimal places over in a double

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

因此我将双精度值设置为等于1234，我想将小数点后移一位使其等于12.34为此，我将.1乘以1234两次，有点像这样double x = 1234;for(int i=1;i<=2;i++){ x = x*.1;}System.out.println(x);这将打印结果"12.340000000000002“有没有一...

问将小数位移到双精度
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将小数位移到双精度EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将小数位移到双精度
EN