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

• • 问题出现的情况
  • 为什么会存在丢失精度的问题？TODO
  • 正确计算浮点数的运算
  • 我们基于 BigDecimalUtil 做一些测试功能

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

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

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

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


public class BigDecimalUtil {

    
    private static final int DEF_DIV_SCALE = 10;

    private BigDecimalUtil() {
    }

    
    public static double add(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.add(b2).doublevalue();
    }

    
    public static double subtract(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.subtract(b2).doublevalue();
    }

    
    public static double multiply(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.multiply(b2).doublevalue();
    }

    
    public static double divide(double v1, double v2) {
        return divide(v1, v2, DEF_DIV_SCALE);
    }

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

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

    
    public static float convertToFloat(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.floatValue();
    }

    
    public static int convertsToInt(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.intValue();
    }

    
    public static long convertsToLong(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.longValue();
    }

    
    public static double returnMax(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.max(b2).doublevalue();
    }

    
    public static double returnMin(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.min(b2).doublevalue();
    }

    
    public static int compareTo(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.compareTo(b2);
    }

}

        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