Java浮点数float和double精确计算的精度误差问题总结

1、float整数计算误差

案例：会员积分字段采用float类型，导致计算会员积分时，7位整数的数据计算结果出现误差。

原因：超出float精度范围，无法精确计算。

float和double的精度是由尾数的位数来决定的。浮点数在内存中是按科学计数法来存储的，其整数部分始终是一个隐含着的“1”，由于它是不变的，故不能对精度造成影响。

float：2^23 = 8388608，一共七位，这意味着最多能有7位有效数字，但绝对能保证的为6位，也即float的精度为6~7位有效数字；

double：2^52 = 4503599627370496，一共16位，同理，double的精度为15~16位。

难道只是位数多大的问题，字段类型换成double就可以解决吗？对于本案例是这样，因为都是整数计算，但如果有小数位，就不一定了，见下面案例。

2、double小数转bigdecimal后四舍五入计算有误差

案例：

double g= 12.35;

BigDecimal bigG=new BigDecimal(g).setScale(1, BigDecimal.ROUND_HALF_UP); //期望得到12.4

System.out.println("test G:"+bigG.doubleValue());

test G:12.3

原因：

定义double g= 12.35;  而在计算机中二进制表示可能这是样：定义了一个g=12.34444444444444449，

new BigDecimal(g)   g还是12.34444444444444449 new BigDecimal(g).setScale(1, BigDecimal.ROUND_HALF_UP); 得到12.3正确的定义方式是使用字符串构造函数：new BigDecimal("12.35").setScale(1, BigDecimal.ROUND_HALF_UP)

3、float和double做四则运算误差

案例：

public class Test{

public static void main(String args[]){        System.out.println(0.05+0.01);        System.out.println(1.0-0.42);        System.out.println(4.015*100);        System.out.println(123.3/100);    }}

结果：

0.0600000000000000050.5800000000000001401.499999999999941.2329999999999999

原因：

那么为什么会出现精度丢失呢？在查阅了一些资料以后，我稍微有了一些头绪，下面是本人的愚见，仅供参考。

首先得从计算机本身去讨论这个问题。我们知道，计算机并不能识别除了二进制数据以外的任何数据。无论我们使用何种编程语言，在何种编译环境下工作，都要先 把源程序翻译成二进制的机器码后才能被计算机识别。以上面提到的情况为例，我们源程序里的2.4是十进制的，计算机不能直接识别，要先编译成二进制。但问 题来了，2.4的二进制表示并非是精确的2.4，反而最为接近的二进制表示是2.3999999999999999。原因在于浮点数由两部分组成：指数和尾数，这点如果知道怎样进行浮点数的二进制与十进制转换，应该是不难理解的。如果在这个转换的过程中，浮点数参与了计算，那么转换的过程就会变得不可预 知，并且变得不可逆。我们有理由相信，就是在这个过程中，发生了精度的丢失。而至于为什么有些浮点计算会得到准确的结果，应该也是碰巧那个计算的二进制与 十进制之间能够准确转换。而当输出单个浮点型数据的时候，可以正确输出，如

double d = 2.4;

System.out.println(d);

输出的是2.4，而不是2.3999999999999999。也就是说，不进行浮点计算的时候，在十进制里浮点数能正确显示。这更印证了我以上的想法，即如果浮点数参与了计算，那么浮点数二进制与十进制间的转换过程就会变得不可预知，并且变得不可逆。

事实上，浮点数并不适合用于精确计算，而适合进行科学计算。这里有一个小知识：既然float和double型用来表示带有小数点的数，那为什么我们不称 它们为“小数”或者“实数”，要叫浮点数呢？因为这些数都以科学计数法的形式存储。当一个数如50.534，转换成科学计数法的形式为5.053e1，它 的小数点移动到了一个新的位置（即浮动了）。可见，浮点数本来就是用于科学计算的，用来进行精确计算实在太不合适了。

4、bigdecimal构造函数使用不当带来异常

案例：

BigDecimal其中一个构造函数以双精度浮点数作为输入，另一个以整数和换算因子作为输入，还有一个以小数的 String 表示作为输入。要小心使用 BigDecimal(double) 构造函数，因为如果不了解它，会在计算过程中产生舍入误差。请使用基于整数或 String 的构造函数。

如果使用 BigDecimal(double) 构造函数不恰当，在传递给 JDBC setBigDecimal() 方法时，会造成似乎很奇怪的 JDBC 驱动程序中的异常。例如，考虑以下 JDBC 代码，该代码希望将数字 0.01 存储到小数字段：

PreparedStatement ps =
    connection.prepareStatement("INSERT INTO Foo SET name=?, value=?");
  ps.setString(1, "penny");
  ps.setBigDecimal(2, new BigDecimal(0.01));
  ps.executeUpdate();

在执行这段似乎无害的代码时会抛出一些令人迷惑不解的异常（这取决于具体的 JDBC 驱动程序），因为 0.01 的双精度近似值会导致大的换算值，这可能会使 JDBC 驱动程序或数据库感到迷惑。JDBC 驱动程序会产生异常，但可能不会说明代码实际上错在哪里，除非意识到二进制浮点数的局限性。相反，使用 BigDecimal("0.01") 或 BigDecimal(1, 2) 构造 BigDecimal 来避免这类问题，因为这两种方法都可以精确地表示小数。

5、解决浮点数精确计算有误差的方法

在《Effective   Java》这本书中也提到这个原则，float和double只能用来做科学计算或者是工程计算，在商业计算中我们要用java.math.BigDecimal。使用BigDecimal并且一定要用String来够造。

BigDecimal用哪个构造函数？

BigDecimal(double val) BigDecimal(String val)   上面的API简要描述相当的明确，而且通常情况下，上面的那一个使用起来要方便一些。我们可能想都不想就用上了，会有什么问题呢？等到出了问题的时候，才发现参数是double的构造方法的详细说明中有这么一段：Note: the results of this constructor can be somewhat unpredictable. One might assume that new BigDecimal(.1) is exactly equal to .1, but it is actually equal to .1000000000000000055511151231257827021181583404541015625. This is so because .1 cannot be represented exactly as a double (or, for that matter, as a binary fraction of any finite length). Thus, the long value that is being passed in to the constructor is not exactly equal to .1, appearances nonwithstanding. The (String) constructor, on the other hand, is perfectly predictable: new BigDecimal(".1") is exactly equal to .1, as one would expect. Therefore, it is generally recommended that the (String) constructor be used in preference to this one.原来我们如果需要精确计算，非要用String来够造BigDecimal不可！

6、定点数和浮点数的区别

在计算机系统的发展过程中，曾经提出过多种方法表达实数。典型的比如相对于浮点数的定点数（Fixed Point Number）。在这种表达方式中，小数点固定的位于实数所有数字中间的某个位置。货币的表达就可以使用这种方式，比如 99.00 或者 00.99 可以用于表达具有四位精度（Precision），小数点后有两位的货币值。由于小数点位置固定，所以可以直接用四位数值来表达相应的数值。SQL 中的 NUMBER 数据类型就是利用定点数来定义的。还有一种提议的表达方式为有理数表达方式，即用两个整数的比值来表达实数。

定点数表达法的缺点在于其形式过于僵硬，固定的小数点位置决定了固定位数的整数部分和小数部分，不利于同时表达特别大的数或者特别小的数。最终，绝大多数现代的计算机系统采纳了所谓的浮点数表达方式。这种表达方式利用科学计数法来表达实数，即用一个尾数（Mantissa ），一个基数（Base），一个指数（Exponent）以及一个表示正负的符号来表达实数。比如 123.45 用十进制科学计数法可以表达为 1.2345 × 102 ，其中 1.2345 为尾数，10 为基数，2 为指数。浮点数利用指数达到了浮动小数点的效果，从而可以灵活地表达更大范围的实数。

在MySQL中使用浮点数类型和定点数类型来表示小数。浮点数类型包括单精度浮点数（FLOAT型）和双精度浮点数（DOUBLE型）。定点数类型就是DECIMAL型。MySQL的浮点数类型和定点数类型如下表所示：

类型名称 字节数 负数的取值范围 非负数的取值范围
FLOAT 4 -3.402823466E+38～-1.175494351E-38 0和1.175494351E-38～3.402823466E+38
DOUBLE 8 -1.7976931348623157E+308～-2.2250738585072014E-308 0和2.2250738585072014E-308～1.7976931348623157E+308
DECIMAL(M,D)或DEC(M,D) M+2 同DOUBLE型 同DOUBLE型

从上表中可以看出，DECIMAL型的取值范围与DOUBLE相同。但是，DECIMAL的有效取值范围由M和D决定，而且DECIMAL型的字节数是M+2，也就是说，定点数的存储空间是根据其精度决定的。

7、bigdecimal比等方法

如浮点类型一样， BigDecimal 也有一些令人奇怪的行为。尤其在使用 equals() 方法来检测数值之间是否相等时要小心。 equals() 方法认为，两个表示同一个数但换算值不同（例如， 100.00 和 100.000 ）的 BigDecimal 值是不相等的。然而， compareTo() 方法会认为这两个数是相等的，所以在从数值上比较两个 BigDecimal 值时，应该使用 compareTo() 而不是 equals() 。

另外还有一些情形，任意精度的小数运算仍不能表示精确结果。例如， 1 除以 9 会产生无限循环的小数 .111111... 。出于这个原因，在进行除法运算时， BigDecimal 可以让您显式地控制舍入。 movePointLeft() 方法支持 10 的幂次方的精确除法。

与零比较：

int r=big_decimal.compareTo(BigDecimal.Zero); //和0，Zero比较

if(r==0) //等于if(r==1) //大于if(r==-1) //小于

8、简化bigdecimal计算的小工具类

如果我们要做一个加法运算，需要先将两个浮点数转为String，然后够造成BigDecimal，在其中一个上调用add方法，传入另一个作为参数，然后把运算的结果（BigDecimal）再转换为浮点数。你能够忍受这么烦琐的过程吗？网上提供的工具类Arith来简化操作。它提供以下静态方法，包括加减乘除和四舍五入：

public   static   double   add(double   v1,double   v2)

public   static   double   sub(double   v1,double   v2)   public   static   double   mul(double   v1,double   v2)   public   static   double   div(double   v1,double   v2)   public   static   double   div(double   v1,double   v2,int   scale)   public   static   double   round(double   v,int   scale)

  1. import java.math.BigDecimal;
  2. /**
  3. * 进行BigDecimal对象的加减乘除，四舍五入等运算的工具类
  4. * @author ameyume
  5. *
  6. */
  7. public class Arith {
  8. /**
  9. * 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精
  10. * 确的浮点数运算，包括加减乘除和四舍五入。
  11. */
  12. //默认除法运算精度
  13. private static final int DEF_DIV_SCALE = 10;
  14. //这个类不能实例化
  15. private Arith(){
  16. }
  17. /**
  18. * 提供精确的加法运算。
  19. * @param v1 被加数
  20. * @param v2 加数
  21. * @return 两个参数的和
  22. */
  23. public static double add(double v1,double v2){
  24. BigDecimal b1 = new BigDecimal(Double.toString(v1));
  25. BigDecimal b2 = new BigDecimal(Double.toString(v2));
  26. return b1.add(b2).doubleValue();
  27. }
  28. /**
  29. * 提供精确的减法运算。
  30. * @param v1 被减数
  31. * @param v2 减数
  32. * @return 两个参数的差
  33. */
  34. public static double sub(double v1,double v2){
  35. BigDecimal b1 = new BigDecimal(Double.toString(v1));
  36. BigDecimal b2 = new BigDecimal(Double.toString(v2));
  37. return b1.subtract(b2).doubleValue();
  38. }
  39. /**
  40. * 提供精确的乘法运算。
  41. * @param v1 被乘数
  42. * @param v2 乘数
  43. * @return 两个参数的积
  44. */
  45. public static double mul(double v1,double v2){
  46. BigDecimal b1 = new BigDecimal(Double.toString(v1));
  47. BigDecimal b2 = new BigDecimal(Double.toString(v2));
  48. return b1.multiply(b2).doubleValue();
  49. }
  50. /**
  51. * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
  52. * 小数点以后10位，以后的数字四舍五入。
  53. * @param v1 被除数
  54. * @param v2 除数
  55. * @return 两个参数的商
  56. */
  57. public static double div(double v1,double v2){
  58. return div(v1,v2,DEF_DIV_SCALE);
  59. }
  60. /**
  61. * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
  62. * 定精度，以后的数字四舍五入。
  63. * @param v1 被除数
  64. * @param v2 除数
  65. * @param scale 表示表示需要精确到小数点以后几位。
  66. * @return 两个参数的商
  67. */
  68. public static double div(double v1,double v2,int scale){
  69. if(scale<0){
  70. throw new IllegalArgumentException(
  71. "The scale must be a positive integer or zero");
  72. }
  73. BigDecimal b1 = new BigDecimal(Double.toString(v1));
  74. BigDecimal b2 = new BigDecimal(Double.toString(v2));
  75. return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
  76. }
  77. /**
  78. * 提供精确的小数位四舍五入处理。
  79. * @param v 需要四舍五入的数字
  80. * @param scale 小数点后保留几位
  81. * @return 四舍五入后的结果
  82. */
  83. public static double round(double v,int scale){
  84. if(scale<0){
  85. throw new IllegalArgumentException(
  86. "The scale must be a positive integer or zero");
  87. }
  88. BigDecimal b = new BigDecimal(Double.toString(v));
  89. BigDecimal one = new BigDecimal("1");
  90. return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
  91. }
  92. /**
  93. * 提供精确的类型转换(Float)
  94. * @param v 需要被转换的数字
  95. * @return 返回转换结果
  96. */
  97. public static float convertsToFloat(double v){
  98. BigDecimal b = new BigDecimal(v);
  99. return b.floatValue();
  100. }
  101. /**
  102. * 提供精确的类型转换(Int)不进行四舍五入
  103. * @param v 需要被转换的数字
  104. * @return 返回转换结果
  105. */
  106. public static int convertsToInt(double v){
  107. BigDecimal b = new BigDecimal(v);
  108. return b.intValue();
  109. }
  110. /**
  111. * 提供精确的类型转换(Long)
  112. * @param v 需要被转换的数字
  113. * @return 返回转换结果
  114. */
  115. public static long convertsToLong(double v){
  116. BigDecimal b = new BigDecimal(v);
  117. return b.longValue();
  118. }
  119. /**
  120. * 返回两个数中大的一个值
  121. * @param v1 需要被对比的第一个数
  122. * @param v2 需要被对比的第二个数
  123. * @return 返回两个数中大的一个值
  124. */
  125. public static double returnMax(double v1,double v2){
  126. BigDecimal b1 = new BigDecimal(v1);
  127. BigDecimal b2 = new BigDecimal(v2);
  128. return b1.max(b2).doubleValue();
  129. }
  130. /**
  131. * 返回两个数中小的一个值
  132. * @param v1 需要被对比的第一个数
  133. * @param v2 需要被对比的第二个数
  134. * @return 返回两个数中小的一个值
  135. */
  136. public static double returnMin(double v1,double v2){
  137. BigDecimal b1 = new BigDecimal(v1);
  138. BigDecimal b2 = new BigDecimal(v2);
  139. return b1.min(b2).doubleValue();
  140. }
  141. /**
  142. * 精确对比两个数字
  143. * @param v1 需要被对比的第一个数
  144. * @param v2 需要被对比的第二个数
  145. * @return 如果两个数一样则返回0，如果第一个数比第二个数大则返回1，反之返回-1
  146. */
  147. public static int compareTo(double v1,double v2){
  148. BigDecimal b1 = new BigDecimal(v1);
  149. BigDecimal b2 = new BigDecimal(v2);
  150. return b1.compareTo(b2);
  151. }
  152. }

参考：

http://justjavac.iteye.com/blog/1073775

http://www.iteye.com/problems/51604

http://blog.163.com/howl_prowler/blog/static/2661971520114553211964/

http://www.cnblogs.com/wingsless/p/3426108.html

http://zhidao.baidu.com/link?url=2L4pkHgVCXlwEeDM0GRHY2gYUwR9d2JC3knqxvHwdyrrdz_LwK92gVAaIy3hhKEQYdUwNjMLe_RJO3cl8sJvbcAnFK-_rMS4Oy_viystUEe

时间： 2024-10-14 10:09:13

Java浮点数float和double精确计算的精度误差问题总结的相关文章

Java 浮点数 float或double类型的表示范围和精度

隐约记得,浮点数判断大小好像有陷阱,因为底层的二进制数不能精确表示所有的小数.有时候会产生让人觉得莫名其妙的事情. 如在java中, 0.99999999f==1f //true 0.9f==1f //false 要明白这些,首先要搞清楚float和double在内存结构 1.内存结构 float和double的范围是由指数的位数来决定的. float的指数位有8位,而double的指数位有11位,分布如下: float: 1bit(符号位) 8bits(指数位) 23bits(尾数位) dou

精确计算java中float和double的精度

[本文相关的代码放在github上,地址为:https://github.com/VigourJiang/StructuredFloat] Java中double类型的格式是遵循IEEE 754标准的.尽管数学意义上的小数是连续的,但double仅仅能表示其中的一些离散点,把这些离散点组成的集合记为S,S的大小还是有限的.如果要保存的小数P刚好在集合S内,那么double类型就能精确的表示P:否则double类型只能从集合S中找一个与P最近的离散点P'代替P. 以上表述对于float也成立.IE

java控制float和double的精度

在做读取Excel表格数据时,碰到有小数点的数字,用double和float来求和时会多出好多位小数,看起来总觉得怪怪的,怎样控制它的长度呢? DecimalFormat df = new DecimalFormat("########.0"); //四舍五入 value = Double.parseDouble(df.format(value)); 我这里是控制一位小数,如果要求两位,就写成########.00 java控制float和double的精度,布布扣,bubuko.co

float和double的范围和精度，Oracle的Number类型

double.float都是浮点型.double(双精度型)比float(单精度型)存的数据更准确些,占的空间也更大.double精度是float的两倍,所以需要更精确的计算常使用double. 单精度浮点数在机内占4个字节,用32位二进制描述.双精度浮点数在机内占8个字节,用64位二进制描述. 浮点数在机内用指数型式表示,分解为:数符,尾数,指数符,指数四部分.数符占1位二进制,表示数的正负.指数符占1位二进制,表示指数的正负.尾数表示浮点数有效数字,0.xxxxxxx,但不存开头的0和点指数

IEEE浮点数float、double的存储结构

众所周知,C的float.VB的Single都是32位浮点数变量类型(也叫单精度浮点数),C的double和VB的Double则都是64位的浮点数变量类型(也叫双精度浮点数).有些编译器还支持更屌的long double(貌似是80位还是128位的我不清楚,总之存在这种变态玩意儿.)那么这些浮点数从最底层的角度来看,它们是怎么存储的呢?我来举个例子解释下.计算机用的是二进制,如果我用二进制跟大家解释大家可能觉得看不懂,那我就用十进制来跟大家解释.浮点数分三个部分,第一个部分是有效数字,第二个部分

Java中float和double转换的问题

为什么double转float不会出现数据误差,而float转double却误差如此之大?   double d = 3.14; float f = (float)d; System.out.println(f); 输出结果是:3.14; float f = 127.1f; double d = f; System.out.println(d); 输出结果是:127.0999984741211 为什么结果会是这样呢? 如何避免这样的问题发生,让float转double能得到实际的数据? 解决办法

float与double的范围和精度

1 范围 float和double的范围是由指数的位数来决定的. float的指数位有8位,而double的指数位有11位,分布如下: float: 1bit(符号位) 8bits(指数位) 23bits(尾数位) double: 1bit(符号位) 11bits(指数位) 52bits(尾数位) 于是,float的指数范围为-127~+128,而double的指数范围为-1023~+1024,并且指数位是按补码的形式来划分的.其中负指数决定了浮点数所能表达的绝对值最小的非零数:而正指数决定了浮

float及double类型减法运算时精度丢失问题

当float和double类型在进行减法运算时,会出现精度丢失问题,这种问题主要是由于计算机中普遍使用2进制所造成的.在此做为记录,防止日后遗忘.     public static void main(String[] args) {         float a = 2.1f;         float b = 2.0f;         float c = a - b;         System.out.println("a-b=" + c);     }     //输

JAVA中float与double的区

float是单精度类型,精度是8位有效数字,取值范围是10的-38次方到10的38次方,float占用4个字节的存储空间 double是双精度类型,精度是17位有效数字,取值范围是10的-308次方到10的308次方,double占用8个字节的存储空间 当你不声明的时候,默认小数都用double来表示,所以如果要用float的话,则应该在其后加上f 例如:float a=1.3; 则会提示不能将double转化成float  这成为窄型转化 如果要用float来修饰的话,则应该使用float a