zoukankan      html  css  js  c++  java
  • Java中如何解决double和float精度不准的问题

    我们知道浮点数是无法在计算机中准确表示的,例如0.1在计算机中只是表示成了一个近似值,因此,浮点数的运算结果具有不可预知性。

     

    在进行数字运算时,如果有double或float类型的浮点数参与计算,偶尔会出现计算不准确的情况。如以下示例代码:

     
    1. package ex;  
    2.   
    3. public class BigDeciTest {  
    4.     public static void main(String[] args){  
    5.         System.out.println(0.05+0.01);  
    6.         System.out.println(1.0-0.42);  
    7.         System.out.println(4.015*100);  
    8.         System.out.println(123.3/100);  
    9.           
    10.     }  
    11. }  
    上述代码执行结果如下:
    1. 0.060000000000000005  
    2. 0.5800000000000001  
    3. 401.49999999999994  
    4. 1.2329999999999999  

    在大多数情况下,使用double和float计算的结果是准确的,但是在一些精度要求很高的系统中,这种问题是非常严重的。

     

    在《Effective Java》中提到一个原则,那就是float和double只能用来作科学计算或者是工程计算,但在商业计算中我们要用java.math.BigDecimal,通过使用BigDecimal类我们可以解决上述问题,实例代码如下:

    1. package ex;  
    2.   
    3. import java.math.*;  
    4.   
    5. public class BigDecimalDemo {  
    6.     public static void main(String[] args){  
    7.         System.out.println(ArithUtil.add(0.010.05));  
    8.         System.out.println(ArithUtil.sub(1.00.42));  
    9.         System.out.println(ArithUtil.mul(4.015100));  
    10.         System.out.println(ArithUtil.div(123.3100));  
    11.     }  
    12. }  
    13.   
    14. class ArithUtil{  
    15.     private static final int DEF_DIV_SCALE=10;  
    16.       
    17.     private ArithUtil(){}  
    18.     //精确的加法算法
    19.     public static double add(double d1,double d2){  
    20.         BigDecimal b1=new BigDecimal(Double.toString(d1));  
    21.         BigDecimal b2=new BigDecimal(Double.toString(d2));  
    22.         return b1.add(b2).doubleValue();  
    23.           
    24.     }  
    25.     //精确的减法算法  
    26.     public static double sub(double d1,double d2){  
    27.         BigDecimal b1=new BigDecimal(Double.toString(d1));  
    28.         BigDecimal b2=new BigDecimal(Double.toString(d2));  
    29.         return b1.subtract(b2).doubleValue();  
    30.           
    31.     }  
    32.     //精确的乘法算法  
    33.     public static double mul(double d1,double d2){  
    34.         BigDecimal b1=new BigDecimal(Double.toString(d1));  
    35.         BigDecimal b2=new BigDecimal(Double.toString(d2));  
    36.         return b1.multiply(b2).doubleValue();  
    37.           
    38.     }  
    39.     //相对精确的除法运算,当发生除不尽的情况时,精确到小数点以后10位  
    40.     public static double div(double d1,double d2){  
    41.   
    42.         return div(d1,d2,DEF_DIV_SCALE);  
    43.           
    44.     }  
    45.     //相对精确的除法运算,当发生除不尽的情况时,精确到小数点以后指定精度(scale),再往后的数字四舍五入
    46.     public static double div(double d1,double d2,int scale){  
    47.         if(scale<0){  
    48.             throw new IllegalArgumentException("The scale must be a positive integer or zero");  
    49.         }  
    50.         BigDecimal b1=new BigDecimal(Double.toString(d1));  
    51.         BigDecimal b2=new BigDecimal(Double.toString(d2));  
    52.         return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();  
    53.           
    54.     }  
    55.       
    56. }  

    运行结果如下:
    1. 0.06  
    2. 0.58  
    3. 401.5  
    4. 1.233 
    说明:
      虽然BigDecimal类的构造方法很多,但是我们只使用了带String类型的构造函数。
      1、BigDecimal(double val):构造函数的结果有一定的不可预知性,比如 new BigDecimal(0.1)可能认为就是0.1,但是实际上可能等于0.10000000006642423,这是因为0.1无法准确地表示double
      2、BigDecimal(String val):构造函数是完全可以预知的。 new BigDecimal("0.1")创建的BigDecimal,正好等于预期的0.1
     
  • 相关阅读:
    redis_03 _ 高性能IO模型:为什么单线程Redis能那么快
    redis_02 _ 数据结构:快速的Redis有哪些慢操作?
    redis-01 _ 基本架构:一个键值数据库包含什么?
    mysql_28 _ 读写分离有哪些坑
    mysql_27 _ 主库出问题了,从库怎么办
    小程序的转发功能
    简单几何(求交点) UVA 11178 Morley's Theorem
    测试开发CICD——Docker——windows8上环境安装
    测试开发进阶——spring boot——MVC——MyBatis初步了解(转载)
    BZOJ 2226 [Spoj 5971] LCMSum
  • 原文地址:https://www.cnblogs.com/gossip/p/9441292.html
Copyright © 2011-2022 走看看