blocks|key|3214665|text|问题很简单，float的精度是有限的；它不能准确地表示0.0065。(当然，double也是如此:它具有更高的精度，但仍然是有限的。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3214666|另一个问题使上述问题更加明显，那就是0.001是一个double而不是float，所以您的float被提升为double来执行减法，当然，在这一点上，系统无法恢复double本来可以表示的丢失的精度。要解决这个问题，您可以这样写：|3214667|float+f+=+Float.parseFloat("0.0065")+-+0.001f;|code-block|syntax|javascript|3214668|使用0.001f而不是0.001。|3214669|entityMap^0|6|5|R|6|12|6|0|I|5|Q|6|Z|5|19|5|1I|6|29|6|0|0|2|6|B|5|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|P|$]]

The problem is simply that <code>float</code> has finite precision; it cannot represent <code>0.0065</code> exactly. (The same is true of <code>double</code>, of course: it has greater precision, but still finite.)

A further problem, which makes the above problem more obvious, is that <code>0.001</code> is a <code>double</code> rather than a <code>float</code>, so your <code>float</code> is getting promoted to a <code>double</code> to perform the subtraction, and of course at that point the system has no way to recover the missing precision that a <code>double</code> could have represented to begin with. To address that, you would write:

<pre><code>float f = Float.parseFloat("0.0065") - 0.001f;
</code></pre>

using <code>0.001f</code> instead of <code>0.001</code>.

blocks|key|4943715|text|参见What+Every+Computer+Scientist+Should+Know+About+Floating-Point+Arithmetic。你的结果在我看来是正确的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4943716|如果您不喜欢浮点数的工作方式，可以尝试使用BigDecimal之类的方法。|4943717|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html|1|http://docs.oracle.com/javase/1.5.0/docs/api/java/math/BigDecimal.html^0|2|21|0|0|L|A|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

See <a href="http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html" rel="noreferrer">What Every Computer Scientist Should Know About Floating-Point Arithmetic</a>. Your results look correct to me.

If you don't like how floating-point numbers work, try something like <a href="http://docs.oracle.com/javase/1.5.0/docs/api/java/math/BigDecimal.html" rel="noreferrer">BigDecimal</a> instead.

blocks|key|4856402|text|你得到了正确的结果。确切地说，没有0.027这样的float，也没有这样的double。如果你使用float或double，你总是会得到这些错误。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4856403|float和double存储为二进制小数:类似于1/2+%2B+1/4+%2B+1/16...您不能将所有的十进制值精确地存储为有限精度的二进制小数。这在数学上是不可能的。|4856404|唯一的替代方法是使用BigDecimal，您可以使用它来获得精确的十进制值。|4856405|entityMap^0|P|5|11|6|1D|5|1J|6|0|0|5|6|6|0|A|A|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|K|$]]

You're getting the right results. There is no such <code>float</code> as 0.027 exactly, nor is there such a <code>double</code>. You will always get these errors if you use <code>float</code> or <code>double</code>.

<code>float</code> and <code>double</code> are stored as binary fractions: something like 1/2 + 1/4 + 1/16... You can't get all decimal values to be stored exactly as finite-precision binary fractions. It's just not mathematically possible.

The only alternative is to use <code>BigDecimal</code>, which you can use to get exact decimal values.

blocks|key|4943838|text|从Java+Tutorials+page+on+Primitive+Data+Types|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4943839|4943840|如果浮点文字以字母F或f结尾，则它的类型为float；否则，它的类型为double，并且可以选择以字母D或d结尾。|blockquote|style|CODE|4943841|4943842|4943843|所以我认为你的文字(0.001)是双精度的，你从浮点数中减去了双精度。|4943844|试着这样做：|4943845|System.out.println((0.0065F+-+0.001D));+//+0.005500000134110451
System.out.println((0.0065F+-+0.001F));+//+0.0055|code-block|syntax|javascript|4943846|..。然后你就会得到：|4943847|0.005500000134110451
0.0055|4943848|因此，将F后缀添加到文字中，您应该会得到更好的结果：|4943849|Float.parseFloat("0.0065")+-+0.001F
new+Float("0.027")+-+0.001F
Float.valueOf("0.074")+-+0.001F|4943850|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html^0|1|17|0|0|0|9|1|B|1|1F|1|1H|1|0|0|0|A|5|0|0|0|0|0|4|1|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|-4|5|6|7|1E|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|1F|8|@$A|1G|B|1H|H|I]|$A|1I|B|1J|H|I]|$A|1K|B|1L|H|I]|$A|1M|B|1N|H|I]]|9|@]|C|$]]|$1|J|3|-4|5|6|7|1O|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|1P|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1Q|8|@$A|1R|B|1S|H|I]]|9|@]|C|$]]|$1|N|3|O|5|6|7|1T|8|@]|9|@]|C|$]]|$1|P|3|Q|5|R|7|1U|8|@]|9|@]|C|$S|T]]|$1|U|3|V|5|6|7|1V|8|@]|9|@]|C|$]]|$1|W|3|X|5|R|7|1W|8|@]|9|@]|C|$S|T]]|$1|Y|3|Z|5|6|7|1X|8|@$A|1Y|B|1Z|H|I]]|9|@]|C|$]]|$1|10|3|11|5|R|7|20|8|@]|9|@]|C|$S|T]]|$1|12|3|-4|5|6|7|21|8|@]|9|@]|C|$]]]|13|$14|$5|15|16|17|C|$18|19]]]]

From the <a href="http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html" rel="nofollow">Java Tutorials page on Primitive Data Types</a>:

<blockquote>
 A floating-point literal is of type float if it ends with the letter <code>F</code> or <code>f</code>; otherwise its type is double and it can optionally end with the letter <code>D</code> or <code>d</code>.
</blockquote>

So I think your literals (<code>0.001</code>) are doubles and you're subtracting doubles from floats.

Try this instead:

<pre><code>System.out.println((0.0065F - 0.001D)); // 0.005500000134110451
System.out.println((0.0065F - 0.001F)); // 0.0055
</code></pre>

... and you'll get:

<pre><code>0.005500000134110451
0.0055
</code></pre>

So add <code>F</code> suffixes to your literals and you should get better results:

<pre><code>Float.parseFloat("0.0065") - 0.001F
new Float("0.027") - 0.001F
Float.valueOf("0.074") - 0.001F
</code></pre>

blocks|key|4943881|text|我会将你的浮点数转换成一个字符串，然后使用BigDecimal。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4943882|This链接很好地解释了这一点|offset|length|4943883|new+BigDecimal(String.valueOf(yourDoubleValue));|code-block|syntax|javascript|4943884|但是，不要使用BigDecimal双重构造函数，因为您仍然会得到错误|4943885|entityMap|0|LINK|mutability|MUTABLE|url|http://rayfd.me/2007/04/26/the-evil-bigdecimal-constructor/^0|0|0|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

I would convert your float to a string and then use BigDecimal.

<a href="http://rayfd.me/2007/04/26/the-evil-bigdecimal-constructor/" rel="nofollow">This</a> link explains it well

<pre><code>new BigDecimal(String.valueOf(yourDoubleValue));
</code></pre>

Dont use the BigDecimal double constructor though as you will still get errors

blocks|key|4943749|text|长话短说，如果需要任意精度，请使用BigDecimal，而不是float或double。在使用float时，您将看到各种这种性质的舍入问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4943750|顺便说一句，不要使用BigDecimal的float/double构造函数，因为它也会有同样的问题。请改用字符串构造函数。|4943751|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|$]]

Long story short if you require arbitrary precision use BigDecimal not float or double. You will see all sorts of rounding issues of this nature using float.

As an aside be very careful not to use the float/double constructor of BigDecimal because it will have the same issue. Use the String constructor instead.

blocks|key|4856514|text|浮点数不能准确表示十进制数。如果您需要在Java语言中准确地表示一个数字，则应该使用java.math.BigDecimal类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4856515|BigDecimal+d+=+new+BigDecimal("0.0065");|code-block|syntax|javascript|4856516|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|$]]

Floating point cannot accurately represent decimal numbers. If you need an accurate representation of a number in Java, you should use the java.math.BigDecimal class:

<pre><code>BigDecimal d = new BigDecimal("0.0065");
</code></pre>

I notice some issues with the Java float precision

<pre><code> Float.parseFloat("0.0065") - 0.001 // 0.0055000000134110451
 new Float("0.027") - 0.001 // 0.02600000000700354575
 Float.valueOf("0.074") - 0.001 // 0.07399999999999999999
</code></pre>

I not only have a problem with <code>Float</code> but also with <code>Double</code>.

Can someone explain what is happening behind the scenes, and how can we get an accurate number? What would be the right way to handle this when dealing with these issues?

What's the right way to parseFloat in Java

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我注意到Java float精度的一些问题       Float.parseFloat("0.0065") - 0.001  // 0.0055000000134110451       new Float("0.027") - 0.001          // 0.02600000000700354575       Float.valueOf("0.074") - 0.001      /

问在Java中使用parseFloat的正确方法是什么
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中使用parseFloat的正确方法是什么EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中使用parseFloat的正确方法是什么
EN