JAVA double精度丢失问题-Toy模板网

这篇具有很好参考价值的文章主要介绍了JAVA double精度丢失问题。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

double类型精度丢失问题：

0.1*0.1使用计算器计算是0.01，代码里却是0.010000000000000002
javadouble精度丢失,android,java,java

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核心技术卷》书上也是这么写的。
javadouble精度丢失,android,java,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)
javadouble精度丢失,android,java,java
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详解如下：文章来源地址https://www.toymoban.com/news/detail-745259.html

ROUND_UP：非0时，舍弃小数后（整数部分）加1，比如12.49结果为13，-12.49结果为 -13
ROUND_DOWN：直接舍弃小数
ROUND_CEILING：如果 BigDecimal 是正的，则做 ROUND_UP 操作；如果为负，则做 ROUND_DOWN 操作 （一句话：取附近较大的整数）
ROUND_FLOOR: 如果 BigDecimal 是正的，则做 ROUND_DOWN 操作；如果为负，则做 ROUND_UP 操作（一句话：取附近较小的整数）
ROUND_HALF_UP：四舍五入（取更近的整数）
ROUND_HALF_DOWN：跟ROUND_HALF_UP 差别仅在于0.5时会向下取整
ROUND_HALF_EVEN：取最近的偶数
ROUND_UNNECESSARY：不需要取整，如果存在小数位，就抛ArithmeticException 异常

到了这里，关于JAVA double精度丢失问题的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！