本篇要点

简单描述浮点数十进制转二进制精度丢失的原因。
介绍几种创建BigDecimal方式的区别。
整理了高精度计算的工具类。
学习了阿里巴巴Java开发手册关于BigDecimal比较相等的规定。

经典问题：浮点数精度丢失

精度丢失的问题是在其他计算机语言中也都会出现，float和double类型的数据在执行二进制浮点运算的时候，并没有提供完全精确的结果。产生误差不在于数的大小，而是因为数的精度。

关于浮点数存储精度丢失的问题，话题过于庞大，感兴趣的同学可以自行搜索一下

这里简单讨论一下十进制数转二进制为什么会出现精度丢失的现象，十进制数分为整数部分和小数部分，我们分开来看看就知道原因为何：

十进制整数如何转化为二进制整数？

将被除数每次都除以2，只要除到商为0就可以停止这个过程。

15 / 2 = 2 余 1
22 / 2 = 1 余 0
31 / 2 = 0 余 1 
4    
5// 结果为 101

这个算法永远都不会无限循环，整数永远都可以使用二进制数精确表示，但小数呢？

十进制小数如何转化为二进制数？

每次将小数部分乘2，取出整数部分，如果小数部分为0，就可以停止这个过程。

10.1 * 2 = 0.2 取整数部分0
20.2 * 2 = 0.4 取整数部分0
30.4 * 2 = 0.8 取整数部分0
40.8 * 2 = 1.6 取整数部分1
50.6 * 2 = 1.2 取整数部分1
60.2 * 2 = 0.4 取整数部分0 
7
8//... 我想写到这就不必再写了，你应该也已经发现，上面的过程已经开始循环，小数部分永远不能为0

这个算法有一定概率会存在无限循环，即无法用有限长度的二进制数表示十进制的小数，这就是精度丢失问题产生的原因。

如何用BigDecimal解决double精度问题？

我们已经明白为什么精度会存在丢失现象，那么我们就应该知道，当某个业务场景对double数据的精度要求非常高时，就必须采取某种手段来处理这个问题，这也是BigDecimal为什么会被广泛应用于金额支付场景中的原因啦。

BigDecimal类位于java.math包下，用于对超过16位有效位的数进行精确的运算。一般来说，double类型的变量可以处理16位有效数，但实际应用中，如果超过16位，就需要BigDecimal类来操作。

既然这样，那用BigDecimal就能够很好解决这个问题咯？

1public static void main(String[] args) {
2		// 方法1
3        BigDecimal a = new BigDecimal(0.1);
4        System.out.println("a --> " + a);
5		// 方法2
6        BigDecimal b = new BigDecimal("0.1");
7        System.out.println("b --> " + b);
8		// 方法3
9        BigDecimal c = BigDecimal.valueOf(0.1);
10        System.out.println("c --> " + c);
11    }

你可以思考一下，控制台输出会是啥。

1a --> 0.1000000000000000055511151231257827021181583404541015625
2b --> 0.1
3c --> 0.1

可以看到，使用方法一的构造函数仍然出现了精度丢失的问题，而方法二和方法三符合我们的预期，为什么会这样呢？

这三个方法其实对应着三种不同的构造函数：

1// 传入double
2	public BigDecimal(double val) {
3        this(val,MathContext.UNLIMITED);
4    }
5	// 传入string
6    public BigDecimal(String val) {
7        this(val.toCharArray(), 0, val.length());
8    }
9
10    public static BigDecimal valueOf(double val) {
11        // Reminder: a zero double returns '0.0', so we cannot fastpath
12        // to use the constant ZERO.  This might be important enough to
13        // justify a factory approach, a cache, or a few private
14        // constants, later.
15        // 可以看到实际上就是第二种
16        return new BigDecimal(Double.toString(val));
17    }
18

关于这三个构造函数，JDK已经给出了解释，并用Notes标注：

为了防止以后图片可能会存在显示问题，这里再记录一下：

new BigDecimal(double val)

该方法是不可预测的，以0.1为例，你以为你传了一个double类型的0.1，最后会返回一个值为0.1的BigDecimal吗？不会的，原因在于，0.1无法用有限长度的二进制数表示，无法精确地表示为双精度数，最后的结果会是0.100000xxx。

new BigDecimal(String val)

该方法是完全可预测的，也就是说你传入一个字符串"0.1"，他就会给你返回一个值完全为0，1的BigDecimal，官方也表示，能用这个构造函数就用这个构造函数叭。

BigDecimal.valueOf(double val)

第二种构造方式已经足够优秀，可你还是想传入一个double值，怎么办呢？官方其实提供给你思路并且实现了它，可以使用Double.toString(double val)先将double值转为String，再调用第二种构造方式，你可以直接使用静态方法：valueOf(double val)。

Double的加减乘除运算工具类

BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。网上有很多这样的工具类，这边直接贴一下，逻辑不难，主要为了简化项目中频繁互相转化的问题。

1/**
2 * 用于高精确处理常用的数学运算
3 */
4public class ArithmeticUtils {
5    //默认除法运算精度
6    private static final int DEF_DIV_SCALE = 10;
7
8    /**
9     * 提供精确的加法运算
10     *
11     * @param v1 被加数
12     * @param v2 加数
13     * @return 两个参数的和
14     */
15
16    public static double add(double v1, double v2) {
17        BigDecimal b1 = new BigDecimal(Double.toString(v1));
18        BigDecimal b2 = new BigDecimal(Double.toString(v2));
19        return b1.add(b2).doubleValue();
20    }
21
22    /**
23     * 提供精确的加法运算
24     *
25     * @param v1 被加数
26     * @param v2 加数
27     * @return 两个参数的和
28     */
29    public static BigDecimal add(String v1, String v2) {
30        BigDecimal b1 = new BigDecimal(v1);
31        BigDecimal b2 = new BigDecimal(v2);
32        return b1.add(b2);
33    }
34
35    /**
36     * 提供精确的加法运算
37     *
38     * @param v1    被加数
39     * @param v2    加数
40     * @param scale 保留scale 位小数
41     * @return 两个参数的和
42     */
43    public static String add(String v1, String v2, int scale) {
44        if (scale < 0) {
45            throw new IllegalArgumentException(
46                    "The scale must be a positive integer or zero");
47        }
48        BigDecimal b1 = new BigDecimal(v1);
49        BigDecimal b2 = new BigDecimal(v2);
50        return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
51    }
52
53    /**
54     * 提供精确的减法运算
55     *
56     * @param v1 被减数
57     * @param v2 减数
58     * @return 两个参数的差
59     */
60    public static double sub(double v1, double v2) {
61        BigDecimal b1 = new BigDecimal(Double.toString(v1));
62        BigDecimal b2 = new BigDecimal(Double.toString(v2));
63        return b1.subtract(b2).doubleValue();
64    }
65
66    /**
67     * 提供精确的减法运算。
68     *
69     * @param v1 被减数
70     * @param v2 减数
71     * @return 两个参数的差
72     */
73    public static BigDecimal sub(String v1, String v2) {
74        BigDecimal b1 = new BigDecimal(v1);
75        BigDecimal b2 = new BigDecimal(v2);
76        return b1.subtract(b2);
77    }
78
79    /**
80     * 提供精确的减法运算
81     *
82     * @param v1    被减数
83     * @param v2    减数
84     * @param scale 保留scale 位小数
85     * @return 两个参数的差
86     */
87    public static String sub(String v1, String v2, int scale) {
88        if (scale < 0) {
89            throw new IllegalArgumentException(
90                    "The scale must be a positive integer or zero");
91        }
92        BigDecimal b1 = new BigDecimal(v1);
93        BigDecimal b2 = new BigDecimal(v2);
94        return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
95    }
96
97    /**
98     * 提供精确的乘法运算
99     *
100     * @param v1 被乘数
101     * @param v2 乘数
102     * @return 两个参数的积
103     */
104    public static double mul(double v1, double v2) {
105        BigDecimal b1 = new BigDecimal(Double.toString(v1));
106        BigDecimal b2 = new BigDecimal(Double.toString(v2));
107        return b1.multiply(b2).doubleValue();
108    }
109
110    /**
111     * 提供精确的乘法运算
112     *
113     * @param v1 被乘数
114     * @param v2 乘数
115     * @return 两个参数的积
116     */
117    public static BigDecimal mul(String v1, String v2) {
118        BigDecimal b1 = new BigDecimal(v1);
119        BigDecimal b2 = new BigDecimal(v2);
120        return b1.multiply(b2);
121    }
122
123    /**
124     * 提供精确的乘法运算
125     *
126     * @param v1    被乘数
127     * @param v2    乘数
128     * @param scale 保留scale 位小数
129     * @return 两个参数的积
130     */
131    public static double mul(double v1, double v2, int scale) {
132        BigDecimal b1 = new BigDecimal(Double.toString(v1));
133        BigDecimal b2 = new BigDecimal(Double.toString(v2));
134        return round(b1.multiply(b2).doubleValue(), scale);
135    }
136
137    /**
138     * 提供精确的乘法运算
139     *
140     * @param v1    被乘数
141     * @param v2    乘数
142     * @param scale 保留scale 位小数
143     * @return 两个参数的积
144     */
145    public static String mul(String v1, String v2, int scale) {
146        if (scale < 0) {
147            throw new IllegalArgumentException(
148                    "The scale must be a positive integer or zero");
149        }
150        BigDecimal b1 = new BigDecimal(v1);
151        BigDecimal b2 = new BigDecimal(v2);
152        return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
153    }
154
155    /**
156     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
157     * 小数点以后10位，以后的数字四舍五入
158     *
159     * @param v1 被除数
160     * @param v2 除数
161     * @return 两个参数的商
162     */
163
164    public static double div(double v1, double v2) {
165        return div(v1, v2, DEF_DIV_SCALE);
166    }
167
168    /**
169     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
170     * 定精度，以后的数字四舍五入
171     *
172     * @param v1    被除数
173     * @param v2    除数
174     * @param scale 表示表示需要精确到小数点以后几位。
175     * @return 两个参数的商
176     */
177    public static double div(double v1, double v2, int scale) {
178        if (scale < 0) {
179            throw new IllegalArgumentException("The scale must be a positive integer or zero");
180        }
181        BigDecimal b1 = new BigDecimal(Double.toString(v1));
182        BigDecimal b2 = new BigDecimal(Double.toString(v2));
183        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
184    }
185
186    /**
187     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
188     * 定精度，以后的数字四舍五入
189     *
190     * @param v1    被除数
191     * @param v2    除数
192     * @param scale 表示需要精确到小数点以后几位
193     * @return 两个参数的商
194     */
195    public static String div(String v1, String v2, int scale) {
196        if (scale < 0) {
197            throw new IllegalArgumentException("The scale must be a positive integer or zero");
198        }
199        BigDecimal b1 = new BigDecimal(v1);
200        BigDecimal b2 = new BigDecimal(v1);
201        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
202    }
203
204    /**
205     * 提供精确的小数位四舍五入处理
206     *
207     * @param v     需要四舍五入的数字
208     * @param scale 小数点后保留几位
209     * @return 四舍五入后的结果
210     */
211    public static double round(double v, int scale) {
212        if (scale < 0) {
213            throw new IllegalArgumentException("The scale must be a positive integer or zero");
214        }
215        BigDecimal b = new BigDecimal(Double.toString(v));
216        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
217    }
218
219    /**
220     * 提供精确的小数位四舍五入处理
221     *
222     * @param v     需要四舍五入的数字
223     * @param scale 小数点后保留几位
224     * @return 四舍五入后的结果
225     */
226    public static String round(String v, int scale) {
227        if (scale < 0) {
228            throw new IllegalArgumentException(
229                    "The scale must be a positive integer or zero");
230        }
231        BigDecimal b = new BigDecimal(v);
232        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
233    }
234
235    /**
236     * 取余数
237     *
238     * @param v1    被除数
239     * @param v2    除数
240     * @param scale 小数点后保留几位
241     * @return 余数
242     */
243    public static String remainder(String v1, String v2, int scale) {
244        if (scale < 0) {
245            throw new IllegalArgumentException(
246                    "The scale must be a positive integer or zero");
247        }
248        BigDecimal b1 = new BigDecimal(v1);
249        BigDecimal b2 = new BigDecimal(v2);
250        return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
251    }
252
253    /**
254     * 取余数  BigDecimal
255     *
256     * @param v1    被除数
257     * @param v2    除数
258     * @param scale 小数点后保留几位
259     * @return 余数
260     */
261    public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
262        if (scale < 0) {
263            throw new IllegalArgumentException(
264                    "The scale must be a positive integer or zero");
265        }
266        return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
267    }
268
269    /**
270     * 比较大小
271     * 阿里巴巴开发规范明确：比较BigDecimal的等值需要使用compareTo，不可用equals
272     * equals会比较值和精度，compareTo会忽略精度
273     * @param v1 被比较数
274     * @param v2 比较数
275     * @return 如果v1 大于v2 则 返回true 否则false
276     */
277    public static boolean compare(String v1, String v2) {
278        BigDecimal b1 = new BigDecimal(v1);
279        BigDecimal b2 = new BigDecimal(v2);
280        int bj = b1.compareTo(b2);
281        boolean res;
282        if (bj > 0)
283            res = true;
284        else
285            res = false;
286        return res;
287    }
288}
289

阿里巴巴Java开发手册关于BigDecimal的规定

【强制】如上所示BigDecimal的等值比较应使用compareTo()方法，而不是equals()方法。说明：equals()方法会比较值和精度(1.0和1.00返回结果为false),而compareTo()则会忽略精度。

关于这一点，我们来看一个例子就明白了：

1public static void main(String[] args) {
2        BigDecimal a = new BigDecimal("1");
3        BigDecimal b = new BigDecimal("1.0");
4        System.out.println(a.equals(b)); // false
5        System.out.println(a.compareTo(b)); //0 表示相等
6    }

JDK中对这两个方法的解释是这样的：

使用compareTo方法，两个值相等但是精度不同的BigDecimal对象会被认为是相等的，比如2.0和2.00。建议使用x.compareTo(y) <op> 0来表示(<, == , > , >= , != , <=)中的其中一个关系，就表示运算符。
equals方法与compareTo方法不同，此方法仅在两个BigDecimal对象的值和精度都相等时才被认为是相等的，如2.0和2.00就是不相等的。

原文链接：https://www.cnblogs.com/summerday152/p/14202267.html

如果觉得本文对你有帮助，可以关注一下我公众号，回复关键字【面试】即可得到一份Java核心知识点整理与一份面试大礼包！另有更多技术干货文章以及相关资料共享，大家一起学习进步！

Java：利用BigDecimal类巧妙处理Double类型精度丢失