BigDecimal解决浮点数运算精度丢失问题

问题出现的情况

浮点运算的加减乘除的情况

public class BigDecimalTest {
    public static void main(String[] args) {
                double a = 1.0;
        double b = 0.9;

        double c = 0.8;
        double d = 0.7;
        System.out.println(a - b); // 0.09999999999999998
        System.out.println(c - d); // 0.09999999999999998

        // ======================
//        System.out.println(a * b);
//        System.out.println(c * d);


//        BigDecimal bda = new BigDecimal(a);
//        BigDecimal bdb = new BigDecimal(b);
//        BigDecimal bdc = new BigDecimal(c);
//        BigDecimal bdd = new BigDecimal(d);

        // 构造的方式，使用字符串
        BigDecimal bda = BigDecimal.valueOf(a);
        BigDecimal bdb = BigDecimal.valueOf(b);
        BigDecimal bdc = BigDecimal.valueOf(c);
        BigDecimal bdd = BigDecimal.valueOf(d);

        BigDecimal bdab = bda.subtract(bdb);
        BigDecimal bdcd = bdc.subtract(bdd);
        System.out.println(bdab);
        System.out.println(bdcd);

        System.out.println(bdab.compareTo(bdcd)); // 1,表示前者大,0表示相等，-1表示前者小

        // 此时我们想着是两者相等，
        System.out.println(Objects.equals(bdab, bdcd));
        System.out.println(bdab.equals(bdcd));
        System.out.println(BigDecimalUtil.compareTo(a-b, c-d));
    }
}

结果显示：

0.09999999999999998
0.10000000000000009
0.1
0.1
0
true
true
-1

我们可以知道其中有结果是不正确的。所以浮点运算我们不能直接运算，会存在精度丢失的问题。
以上的测试案例，一定记住，构造 BigDecimal 对象的时候，必须要用转化成字符串，不然是有问题的，可以测试两种不同的方式，结果是不一样的。

为什么会存在丢失精度的问题？TODO

// TODO
说明：浮点数采用“尾数+阶码”的编码方式，类似于科学计数法的“有效数字+指数”的表示方式。二进
制无法精确表示大部分的十进制小数（出自 《java开发手册（嵩山版）》）

正确计算浮点数的运算

以下工具类，引用自 github 【 JavaGuide】
地址是 BigDecimal解决浮点数运算精度丢失问题

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 简化BigDecimal计算的小工具类
 */
public class BigDecimalUtil {

    /**
     * 默认除法运算精度
     */
    private static final int DEF_DIV_SCALE = 10;

    private BigDecimalUtil() {
    }

    /**
     * 提供精确的加法运算。
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static double add(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算。
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double subtract(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算。
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double multiply(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 小数点以后10位，以后的数字四舍五入。
     *
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2) {
        return divide(v1, v2, DEF_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入。
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理。
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = BigDecimal.valueOf(v);
        BigDecimal one = new BigDecimal("1");
        return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
    }

    /**
     * 提供精确的类型转换(Float)
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static float convertToFloat(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.floatValue();
    }

    /**
     * 提供精确的类型转换(Int)不进行四舍五入
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static int convertsToInt(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.intValue();
    }

    /**
     * 提供精确的类型转换(Long)
     *
     * @param v 需要被转换的数字
     * @return 返回转换结果
     */
    public static long convertsToLong(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.longValue();
    }

    /**
     * 返回两个数中大的一个值
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 返回两个数中大的一个值
     */
    public static double returnMax(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.max(b2).doubleValue();
    }

    /**
     * 返回两个数中小的一个值
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 返回两个数中小的一个值
     */
    public static double returnMin(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.min(b2).doubleValue();
    }

    /**
     * 精确对比两个数字
     *
     * @param v1 需要被对比的第一个数
     * @param v2 需要被对比的第二个数
     * @return 如果两个数一样则返回0，如果第一个数比第二个数大则返回1，反之返回-1
     */
    public static int compareTo(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.compareTo(b2);
    }

}

我们基于 BigDecimalUtil 做一些测试功能

        double a = 1.0;
        double b = 0.9;

        double c = 0.8;
        double d = 0.7;

        BigDecimal bda = BigDecimal.valueOf(a);
        BigDecimal bdb = BigDecimal.valueOf(b);
        BigDecimal bdc = BigDecimal.valueOf(c);
        BigDecimal bdd = BigDecimal.valueOf(d);

        System.out.println(BigDecimalUtil.divide(a, b));//1.1111111111
        System.out.println(BigDecimalUtil.add(a, b));//1.9
        System.out.println(BigDecimalUtil.multiply(c, d));//0.56
        System.out.println(BigDecimalUtil.convertsToInt(c));//0
        System.out.println(BigDecimalUtil.compareTo(a,b));//1
        System.out.println(BigDecimalUtil.returnMax(a, b));//1.0
        System.out.println(BigDecimalUtil.returnMin(a, b));//0.9