blocks|key|290706|text|编辑。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|290707|不，使用Java中的浮点数无法获得更高的精度，因为浮点数只能包含32位(4字节)。如果您想要更高的精度，那么继续使用双。This也可能有帮助。|offset|length|290708|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/5039165/max-value-can-stored-in-java-float-with-two-digit-precision-2-digit-accuracy^0|0|1O|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

EDIT. 
 No you cannot get any more precise with a float in Java because floats can only contain 32 bits ( 4 bytes). If you want more precision, then continue to use the Double. <a href="https://stackoverflow.com/questions/5039165/max-value-can-stored-in-java-float-with-two-digit-precision-2-digit-accuracy">This</a> might also be helpful

blocks|key|290714|text|float的精度约为7小数点，但由于浮子是以二进制形式存储的，这是一种近似。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|290715|要演示所述浮点值的实际精度，请尝试如下：|290716|double+d+=+1234567.1234;
float+f+=+(float)d;
System.out.printf("%25.9f%25n",+d);
System.out.printf("%25.9f%25n",+Math.nextDown(f));
System.out.printf("%25.9f%25n",+f);
System.out.printf("%25.9f%25n",+Math.nextUp(f));|code-block|syntax|javascript|290717|输出|BOLD|290718|1234567.123400000
1234567.000000000
1234567.125000000
1234567.250000000|290719|如您所见，对于这个数字，有效的十进制精度大约是1位小数位，或8位数字，但是如果您使用数字9876543.9876运行代码，您将得到：|290720|9876543.987600000
9876543.000000000
9876544.000000000
9876545.000000000|290721|只有7位数的精确度。|290722|entityMap^0|0|5|0|0|0|0|2|0|0|18|C|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|13|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|14|8|@$9|15|A|16|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|R|3|S|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|T|3|U|5|J|7|1B|8|@]|D|@]|E|$K|L]]|$1|V|3|W|5|6|7|1C|8|@]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|Y|$]]

The precision of a <code>float</code> is about 7 decimals, but since floats are stored in binary, that's an approximation.

To illustrate the actual precision of the float value in question, try this:

<pre><code>double d = 1234567.1234;
float f = (float)d;
System.out.printf("%.9f%n", d);
System.out.printf("%.9f%n", Math.nextDown(f));
System.out.printf("%.9f%n", f);
System.out.printf("%.9f%n", Math.nextUp(f));
</code></pre>

Output

<pre><code>1234567.123400000
1234567.000000000
1234567.125000000
1234567.250000000
</code></pre>

As you can see, the effective decimal precision is about 1 decimal place for this number, or 8 digits, but if you ran the code with the number <code>9876543.9876</code>, you get:

<pre><code>9876543.987600000
9876543.000000000
9876544.000000000
9876545.000000000
</code></pre>

That's only 7 digits of precision.

blocks|key|336339|text|我只是想知道，在将double转换为float时，不丢失任何精度的最大位数是多少。|type|blockquote|depth|inlineStyleRanges|entityRanges|data|336340|也许你没有意识到这一点，但是N位精度的概念已经是模棱两可。毫无疑问，你的意思是“基数为10的N位数字的精度”。但与人类不同的是，我们的电脑与基地2一起工作。|unstyled|336341|不可能在不丢失精度的情况下将每个数字从基数X转换到基数Y(保留的数字数量有限)，例如，1/3的值在基3中完全准确地表示为"0.1“。在基数10中，它有无限多位数0.3333333333333.同样，基本10中通常完全可表示的数字，例如0.1，需要在基2中表示无限多个数字。另一方面，0.5+(基数10)可以精确地表示为0.1+(基数2)。|336342|所以回到|336343|336344|答案是“这取决于价值”。常用的经验法则“浮点数大约有6到7位小数点精度”只是一种近似。它可以是更多或更少取决于价值。|336345|在处理浮点时，相对精度的概念更有用，停止考虑“数字”，代之以相对误差。任何数字N(在范围内)都是可以表示的，误差最多为N/精度，精度是选择格式的尾数(例如，浮点数23+(%2B1)，双精度52+(%2B1)+)。因此，表示为浮点数的十进制数的最大逼近误差为N/+pow(2，24)。误差可能较小，甚至为零，但永远不会更大。|336346|23%2B1来自于这样一种惯例，即浮点数字是按照选择的指数组织的，因此第一个尾数位总是1(只要有可能)，因此不需要显式存储。物理存储的比特数，例如23，因此允许额外的一位精度。(有一种例外情况，即“只要有可能”就不适用，但让我们在这里忽略这一点)。|336347|TL；博士:浮点数或双数没有固定的十进制数精度。|offset|length|style|BOLD|336348|entityMap^0|0|0|0|0|0|0|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|Z|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|10|8|@]|9|@]|A|$]]|$1|I|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|J|3|K|5|D|7|12|8|@]|9|@]|A|$]]|$1|L|3|M|5|D|7|13|8|@]|9|@]|A|$]]|$1|N|3|O|5|D|7|14|8|@]|9|@]|A|$]]|$1|P|3|Q|5|D|7|15|8|@$R|16|S|17|T|U]]|9|@]|A|$]]|$1|V|3|-4|5|D|7|18|8|@]|9|@]|A|$]]]|W|$]]

<blockquote>
 I just wonder what is the maximum number of digits not to lose any precision when converting double to float.
</blockquote>

Maybe you don't realize it, but the concept of N digits precisions is already ambigous. Doubtlessly you meant "N digits precision in base 10". But unlike humans, our computers work with Base 2.

Its not possible to convert every number from Base X to Base Y (with a limited amount of retained digits) without loss of precision, e.g. the value of 1/3rd is perfectly accurately representable in Base 3 as "0.1". In Base 10 it has an infinite number of digits 0.3333333333333... Likewise, commonly perfectly representable numbers in Base 10, e.g. 0.1 need an infinite number of digits to be represented in Base 2. On the other hand, 0.5 (Base 10) is peferectly accurately representable as 0.1 (Base 2).

So back to

<blockquote>
 I just wonder what is the maximum number of digits not to lose any precision when converting double to float.
</blockquote>

The answer is "it depends on the value". The commonly cited rule of thumb "float has about 6 to 7 digits decimal precision" is just an approximation. It can be much more or much less depending on the value.

When dealing with floating point the concept of relative accuracy is more useful, stop thinking about "digits" and replace it with relative error. Any number N (in range) is representable with an error of (at most) N / accuracy, and the accuracy is the number of mantissa bits in the chosen format (e.g. 23 (+1) for float, 52 (+1) for double). So a decimal number represented as a float is has a maximum approximation error of N / pow(2, 24). The error may be less, even zero, but it is never greater.

The 23+1 comes from the convention that floating point numbers are organized with the exponent chosen such that the first mantissa bit is always a 1 (whenever possible), so it doesn't need to be explicitly stored. The number of physically stored bits, e.g. 23 thus allows for one extra bit of accuracy. (There is an exceptional case where "whenever possible" does not apply, but lets ignore that here).

TL;DR: There is no fixed number of decimal digits accuracy in float or double.

blocks|key|290783|text|这是一个简单的示例，支持不存在安全的十进制数的观点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|290784|考虑0.1。|290785|最近的IEEE+754+64位二进制浮点数具有精确的值0.1000000000000000055511151231257827021181583404541015625.。它将32位二进制浮点转换为0.10000000149011119384765625，比0.1远得多.|290786|即使是一位重要的数字和一位小数位，也可能失去精确性。|290787|除非你真的需要浮子的紧凑性，并且有非常宽松的精度要求，一般情况下最好坚持双倍。|290788|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

This is a simple example in support of the view that there is no safe number of decimal digits. 

Consider 0.1. 

The closest IEEE 754 64-bit binary floating point number has exact value 0.1000000000000000055511151231257827021181583404541015625. It converts to 32-bit binary floating point as 0.100000001490116119384765625, which is considerably further from 0.1.

There can be loss of precision with even a single significant digit and single decimal place.

Unless you really need the compactness of float, and have very relaxed precision requirements, it is generally better to just stick with double.

I am trying to convert double to float in java.

<pre><code>Double d = 1234567.1234;
Float f = d.floatValue();
</code></pre>

I see that the value of f is

<pre><code>1234567.1
</code></pre>

I am not trying to print a string value of float. I just wonder what is the maximum number of digits not to lose any precision when converting double to float. Can i show more than 8 significant digits in java?

Converting double value of 1234567.1234 to float in java

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正试图在java中将double转换为float。Double d = 1234567.1234;Float f = d.floatValue();我看到f的值是1234567.1我不想打印一个字符串值的浮点。我只是想知道，在将double转换为float时，不丢失任何精度的最大位数是多少。我可以在java中显示8个...

问将1234567.1234的双值转换为java中的浮动值
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将1234567.1234的双值转换为java中的浮动值EN