Java中double类型精度丢失的问题_double类型数据加减操作精度丢失解决方法_BigDecimal取整

r囧r小猫 2023-09-30 13:49 119阅读 0赞

BigDecimal在用double做入参的时候，二进制无法精确地表示十进制小数，编译器读到字符串"0.0000002"和“1.0000002”之后，必须把它转成8个字节的double值，也就是1.0000001999999998947288304407265968620777130126953125类似这种。

所以，运行的时候，实际传给BigDecimal构造函数的真正的数值是1.0000001999999998947288304407265968620777130126953125。

**BigDecimal在用String做入参的时候，能够正确地把字符串转化成真正精确的浮点数。**

System.out.println部分，如果入参是string，那么直接输出，如果入参是其他类型，那么会调用Object.toString方法进行转化之后进行输出。而Double.toString会使用一定的精度来四舍五入double，然后再输出。

BigDecimal构造方法上的注释就写了这个问题：

The results of this constructor can be somewhat unpredictable.
    
    \* One might assume that writing {
        @code new BigDecimal(0.1)} in
    
    \* Java creates a {
        @code BigDecimal} which is exactly equal to
    
    \* 0.1 (an unscaled value of 1, with a scale of 1), but it is
    
    \* actually equal to
    
    \* 0.1000000000000000055511151231257827021181583404541015625.
    
    \* This is because 0.1 cannot be represented exactly as a
    
    \* {
        @code double} (or, for that matter, as a binary fraction of
    
    \* any finite length). Thus, the value that is being passed
    
    \* *in* to the constructor is not exactly equal to 0.1,
    
    \* appearances notwithstanding.
    
    The {
        @code String} constructor, on the other hand, is
    
    \* perfectly predictable: writing {
        @code new BigDecimal("0.1")}
    
    \* creates a {
        @code BigDecimal} which is *exactly* equal to
    
    \* 0.1, as one would expect. Therefore, it is generally
    
    \* recommended that the {
        @linkplain #BigDecimal(String)
    
    \* `String` constructor} be used in preference to this one.

补充说明一下：

**Double.toString这个方法输出的是一个String，而且会进行四舍五入处理。**

new BigDecimal(Double.toString(d1))这个入参在处理完毕之后是一个String，调用的是BigDecimal(String val)这个构造方法。

源码里BigDecimal(String val)这个方法是会将val处理成char\[\]数组：

this(val.toCharArray(), 0, val.length());

然后调用BigDecimal(char\[\] in)这个构造方法。

而new BigDecimal(d1)调用的是 BigDecimal(double val)，这个方法进来之后第一件事就是

long valBits = Double.doubleToLongBits(val);

把入参转换成二进制，所以会造成精度丢失。

double相加造成的精度丢失和上面的情况一样，先转成bit之后进行计算，然后精度丢失。

## double类型数据加减操作精度丢失解决方法 ##

double类型数据加减运算时，会出现精度缺失。  
打个比方

double number1 = 1;
    double number2 = 0.2;
    double number3 =number1 + number2 ;

理论上number3会等于1.2；但是在实际的操作过程中会出现1.299999999999这种情况，这就是double类型的数据进行计算时出现精度缺失。  
解决方法是使用java.math.BigDecimal进行计算。

/**
         * 加法运算
         * @param number1
         * @param number2
         * @return
         */
        public static double addDouble(double number1 , double number2) {
        
            BigDecimal bigDecimal1 = new BigDecimal(String.valueOf(number1));
            BigDecimal bigDecimal2 = new BigDecimal(String.valueOf(number2));
            return bigDecimal1.add(bigDecimal2).doubleValue();
        }
    
        /**
         * 减法运算
         * @param number1
         * @param number2
         * @return
         */
        public static double subDouble(double number1, double number2) {
        
            BigDecimal bigDecimal1 = new BigDecimal(String.valueOf(number1));
            BigDecimal bigDecimal2 = new BigDecimal(String.valueOf(number2));
            return bigDecimal1.subtract(bigDecimal2).doubleValue();
        }
    
        /**
         * 乘法运算
         * @param number1
         * @param number2
         * @return
         */
        public static double mul(double number1, double number2) {
        
            BigDecimal bigDecimal1 = new BigDecimal(String.valueOf(number1));
            BigDecimal bigDecimal2 = new BigDecimal(String.valueOf(number2));
            return bigDecimal1.multiply(bigDecimal2).doubleValue();
        }
    
        /**
         * 除法运算
         * @param num
         * @param total
         * @return
         */
        public static BigDecimal divide(double num, double total) {
        
            BigDecimal bigDecimal1 = new BigDecimal(String.valueOf(num));
            BigDecimal bigDecimal2 = new BigDecimal(String.valueOf(total));
            return bigDecimal1.divide(bigDecimal2, 2, BigDecimal.ROUND_HALF_UP);;
        }

## BigDecimal取整 ##

BigDecimal bd = new BigDecimal("12.1");
    long l  = bd.setScale( 0, BigDecimal.ROUND_UP ).longValue(); // 向上取整
    long l  = bd.setScale( 0, BigDecimal.ROUND_DOWN ).longValue(); // 向下取整
    
    * 对于正数而言，ROUND_UP  = ROUND_CEILING，ROUND_DOWN = ROUND_FLOOR

各个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 异常