java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java double精度丢失问题

Java中double精度丢失问题原因及解决办法

作者：雨汨

使用Java double进行运算时,经常出现精度丢失的问题,总是在一个正确的结果左右偏0.0000**1,这篇文章主要给大家介绍了关于Java中double精度丢失问题原因及解决办法,需要的朋友可以参考下

double类型精度丢失问题：

0.1*0.1使用计算器计算是0.01，代码里却是0.010000000000000002

public class HelloWorld {
    public static void main(String []args) {
       double number1 = 0.1;
	   double number2 = 0.1;
	   double result = number1 * number2 ;
	   System.out.println("使用double运算结果: "+result);
    }
}

为什么会这样呢？这就是精度丢失问题造成的。

为什么会出现精度丢失？

因为计算机只能识别0和1，即二进制，无论哪种编程语言，都需要翻译成二进制才能被计算机识别。

很多人还知道这样一句话：这种舍入误差的主要原因是浮点数值采用二进制系统表示， 而在二进制系统中无法精确地表示分数 1/10。这就好像十进制无法精确地表示分数 1/3—样。

针对十进制，1除以3是除不尽的。很好理解，因为我们一直接触的就是十进制，等于0.333333… 很好理解

但是：二进制系统中无法精确地表示分数 1/10。为啥呢。就有点不理解了

《Java核心技术卷》书上也是这么写的。

十进制 转二进制(每次将小数部分乘2，取出整数部分，如果小数部分为0，就可以停止这个过程)：十进制0.1

0.1*2=0.2
0.2*2=0.4
0.4*2=0.8
0.8*2=1.6

0.6*2=1.2
0.2*2=0.4
0.4*2=0.8
//... 应该已经发现，上面的过程已经开始循环，小数部分永远不能为0

怎么解决精度丢失问题？

在商城里面计算订单金额的时候，我们就不得不解决这个问题了，这时候就用到了BigDecimal

BigDecimal类位于java.math包下，用于对超过16位有效位的数进行精确的运算。

一般来说，double类型的变量可以处理16位有效数，

但实际应用中，如果超过16位，就需要BigDecimal类来操作

new BigDecimal(double val)

new BigDecimal(String val)

BigDecimal.valueOf(double val)

将double转为BigDecimal的时候，需要先把double转换为字符串，然后再作为BigDecimal(String val)构造函数的参数，这样才能避免出现精度问题。

import java.math.BigDecimal;

public class BigDecimalUtil {

    /**
     * double类型的加法运算（不需要舍入）
     * @param d1
     * @param d2
     * @return 不加doubleValue()则, 返回BigDecimal对象
     */
    public static double addDouble(double d1, double d2) {
        BigDecimal p1 = new BigDecimal(Double.toString(d1));
        BigDecimal p2 = new BigDecimal(Double.toString(d2));
        return p1.add(p2).doubleValue();
    }

    /**
     * double类型的加法运算（需要舍入）
     * @param d1
     * @param d2
     * @param scale 保留scale位小数
     * @return 不加doubleValue()则, 返回BigDecimal对象
     */
    public static double addDouble(double d1, double d2, int scale) {
        BigDecimal p1 = new BigDecimal(Double.toString(d1));
        BigDecimal p2 = new BigDecimal(Double.toString(d2));
        return p1.add(p2).setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * double类型的超大数值加法运算(超过50 0000)（需要舍入）
     * @param d1
     * @param d2
     * @param scale 保留scale位小数
     * @return 返回字符串，不然double数字会转成科学计数法显示
     */
    public static String addDoubleToStr(double d1, double d2, int scale) {
        BigDecimal p1 = new BigDecimal(Double.toString(d1));
        BigDecimal p2 = new BigDecimal(Double.toString(d2));
        return p1.add(p2).setScale(scale, BigDecimal.ROUND_HALF_UP).toPlainString();
    }

    /**
     * double类型的减法运算
     * @param d1
     * @param d2
     * @return 不加doubleValue()则, 返回BigDecimal对象
     */
    public static double subtractDouble(double d1, double d2) {
        BigDecimal p1 = new BigDecimal(Double.toString(d1));
        BigDecimal p2 = new BigDecimal(Double.toString(d2));
        return p1.subtract(p2).doubleValue();
    }

    /**
     * double类型的减法运算（需要舍入）
     * @param d1
     * @param d2
     * @param scale  保留scale位小数
     * @return  不加doubleValue()则, 返回BigDecimal对象
     */
    public static double subtractDouble(double d1, double d2, int scale) {
        BigDecimal p1 = new BigDecimal(Double.toString(d1));
        BigDecimal p2 = new BigDecimal(Double.toString(d2));
        return p1.subtract(p2).setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * double类型的超大数值减法运算（需要舍入）
     * @param d1
     * @param d2
     * @param scale 保留scale位小数
     * @return  返回字符串，不然double数字会转成科学计数法显示
     */
    public static String subtractDoubleToStr(double d1, double d2, int scale) {
        BigDecimal p1 = new BigDecimal(Double.toString(d1));
        BigDecimal p2 = new BigDecimal(Double.toString(d2));
        return p1.subtract(p2).setScale(scale, BigDecimal.ROUND_HALF_UP).toPlainString();
    }

    /**
     * double类型的乘法运算
     *
     * @param d1
     * @param d2
     * @return 不加doubleValue()则, 返回BigDecimal对象
     */
    public static double multiplyDouble(double d1, double d2) {
        BigDecimal p1 = new BigDecimal(Double.toString(d1));
        BigDecimal p2 = new BigDecimal(Double.toString(d2));
        return p1.multiply(p2).doubleValue();
    }

    /**
     * double类型的乘法运算（需要舍入）
     * @param d1
     * @param d2
     * @param scale 保留scale位小数
     * @return 不加doubleValue()则, 返回BigDecimal对象
     */
    public static double multiplyDouble(double d1, double d2, int scale) {
        BigDecimal p1 = new BigDecimal(Double.toString(d1));
        BigDecimal p2 = new BigDecimal(Double.toString(d2));
        return p1.multiply(p2).setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * double类型的超大数值的乘法运算（需要舍入）
     * @param d1
     * @param d2
     * @param scale 保留scale位小数
     * @return 返回字符串，不然double数字会转成科学计数法显示
     */
    public static String multiplyDoubleToStr(double d1, double d2, int scale) {
        BigDecimal p1 = new BigDecimal(Double.toString(d1));
        BigDecimal p2 = new BigDecimal(Double.toString(d2));
        return p1.multiply(p2).setScale(scale, BigDecimal.ROUND_HALF_UP).toPlainString();
    }

    /**
     * double类型的除法运算（需要舍入）
     *
     * @param d1
     * @param d2
     * @param scale 保留scale位小数
     * @return 不加doubleValue()则, 返回BigDecimal对象
     */
    public static double divideDouble(double d1, double d2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("Parameter error");
        }
        BigDecimal p1 = new BigDecimal(Double.toString(d1));
        BigDecimal p2 = new BigDecimal(Double.toString(d2));
        return p1.divide(p2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * double类型的超大数值的除法运算（需要舍入）
     * @param d1
     * @param d2
     * @param scale 保留scale位小数
     * @return 返回字符串，不然double数字会转成科学计数法显示
     */
    public static String divideDoubleToStr(double d1, double d2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("Parameter error");
        }
        BigDecimal p1 = new BigDecimal(Double.toString(d1));
        BigDecimal p2 = new BigDecimal(Double.toString(d2));
        return p1.divide(p2, scale, BigDecimal.ROUND_HALF_UP).toPlainString();
    }
}

各个roundingMode详解如下：

总结

到此这篇关于Java中double精度丢失问题原因及解决办法的文章就介绍到这了,更多相关Java double精度丢失问题内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文