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);
    }
}
1
2
3
4
5
6
7
8

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

为什么会出现精度丢失？

因为计算机只能识别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
1
2
3
4
5
6
7
8
9

怎么解决精度丢失问题？

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

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

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

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

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();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

各个roundingMode详解如下：

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 异常
1
2
3
4
5
6
7
8