线上慎用 BigDecimal

古城微笑少年丶 2024-02-25 01:59 58阅读 0赞

BigDecimal  
![在这里插入图片描述][14df203aab9f4be0a8ffc8bf61668314.png]

**踩坑一：创建 BigDecimal精度丢失的坑**  
在BigDecimal 中提供了多种创建方式，可以通过new 直接创建，也可以通过 BigDecimal\#valueOf 创建。这两种方式使用不当，也会导致精度问题。如下：

public static void main(String[] args) throws Exception {
        
       BigDecimal b1= new BigDecimal(0.1);
       System.out.println(b1);
       BigDecimal b2= BigDecimal.valueOf(0.1);
       System.out.println(b2);
       BigDecimal b3= BigDecimal.valueOf(0.111111111111111111111111111234);
       System.out.println(b3);
    }

执行结果：

0.1000000000000000055511151231257827021181583404541015625
    0.1
    0.1111111111111111

上面示例中两个方法都传入了double类型的参数0.1但是 b1 还是出现了精度的问题。造成这种问题的原因是 0.1 这个数字计算机是无法精确表示的，送给 BigDecimal 的时候就已经丢精度了，而 BigDecimal\#valueOf 的实现却完全不同。如下源码所示，BigDecimal\#valueOf 中是把浮点数转换成了字符串来构造的BigDecimal，因此避免了问题。

public static BigDecimal valueOf(double val) {
        
       return new BigDecimal(Double.toString(val));
    }

结论：

第一，在使用BigDecimal构造函数时，尽量传递字符串而非浮点类型；  
第二，如果无法满足第一条，则可采用BigDecimal\#valueOf方法来构造初始化值。但是valueOf受double类型精度影响，当传入参数小数点后的位数超过double允许的16位精度还是可能会出现问题的

**踩坑二：等值比较的坑**  
一般在比较两个值是否相等时，都是用equals 方法，但是，在BigDecimal 中使用equals可能会导致结果错误，BigDecimal 中提供了 compareTo 方法，在很多时候需要使用compareTo 比较两个值。如下所示：

public static void main(String[] args){
        
        BigDecimal b1 = new BigDecimal("1.0");
        BigDecimal b2 = new BigDecimal("1.00");
        System.out.println(b1.equals(b2));
        System.out.println(b1.compareTo(b2));
    }

执行结果：

false
    0

出现此种结果的原因是，equals不仅比较了值是否相等，还比较了精度是否相同。示例中，由于两个值的精度不同，所有结果也就不相同。而 compareTo 是只比较值的大小。返回的值为-1（小于），0（等于），1（大于）。

结论

如果比较两个BigDecimal值的大小，采用其实现的compareTo方法；  
如果严格限制精度的比较，那么则可考虑使用equals方法。  
**踩坑三：无限精度的坑**  
BigDecimal 并不代表无限精度，当在两个数除不尽的时候，就会出现无限精度的坑，如下所示：

public static void main(String[] args){
        
       BigDecimal b1 = new BigDecimal("1.0");
        BigDecimal b2 = new BigDecimal("3.0");
        b1.divide(b2);
    }

执行结果：

Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
    	at java.math.BigDecimal.divide(BigDecimal.java:1693)
    	at com.demo.controller.Test.main(Test.java:29)

在官方文档中对该异常有如下说明：

> If the quotient has a nonterminating decimal expansion and the  
> operation is specified to return an exact result, an  
> ArithmeticException is thrown. Otherwise, the exact result of the  
> division is returned, as done for other operations.

大致意思就是，如果在除法（divide）运算过程中，如果商是一个无限小数（如 0.333…），而操作的结果预期是一个精确的数字，那么将会抛出ArithmeticException异常。

此种情况，只需要在使用 divide方法时指定结果的精度即可：

public static void main(String[] args){
        
       BigDecimal b1 = new BigDecimal("1.0");
       BigDecimal b2 = new BigDecimal("3.0");
       System.out.println(b1.divide(b2,2, RoundingMode.HALF_UP));//0.33
    }

结论：

在使用BigDecimal进行（所有）运算时，尽量指定精度和舍入模式。  
**踩坑四：BigDecimal三种字符串输出的坑**  
在BigDecimal 转换成字符串时，有可能输出非你预期的结果。如下所示：

public static void main(String[] args){
        
       BigDecimal bg = new BigDecimal("1E11");
        System.out.println(bg.toString()); // 1E+11
        System.out.println(bg.toPlainString()); // 100000000000
        System.out.println(bg.toEngineeringString()); // 100E+9
    }

执行结果：

1E+11
    100000000000
    100E+9

可以看到三种方式输出的结果可能都不相同，可能这个并不是预期的结果 ，BigDecimal 有三个方法可以转为相应的字符串类型，切记不要用错：

以下内容介绍java.math.BigDecimal下的三个toString方法的区别及用法

toPlainString() : 不使用任何指数。  
toString() ：有必要时使用科学计数法。  
toEngineeringString()：有必要时使用工程计数法。 工程记数法是一种工程计算中经常使用的记录数字的方法，与科学技术法类似，但要求10的幂必须是3的倍数

**踩坑五：使用BigDecimal进行计算时参数不能为NULL**  
在使用BigDecimal类型进行计算时，进行加、减、乘、除、比较大小时，一定要保证参与计算的两个值不能为空，否则会抛出java.lang.NullPointerException异常。

代码示例：

BigDecimal b1 = new BigDecimal("1");
    BigDecimal b2 = null;
    System.out.println("相加："+b2.add(b1));

结果：

Exception in thread "main" java.lang.NullPointerException
    	at com.demo.controller.Test.main(Test.java:14)

**踩坑六：使用BigDecimal进行除法计算时被除数不能为0**  
代码示例：

BigDecimal b1 = new BigDecimal("1");
    BigDecimal b2 = new BigDecimal("0");
    System.out.println(b1.divide(b2));

执行结果：

Exception in thread "main" java.lang.ArithmeticException: Division by zero

**踩坑七：执行顺序不能调换（乘法交换律失效）**  
乘法满足交换律是一个常识，但是在计算机的世界里，会出现不满足乘法交换律的情况；

代码示例：

BigDecimal b1 = BigDecimal.valueOf(1.0);
    BigDecimal b2 = BigDecimal.valueOf(3.0);
    BigDecimal b3 = BigDecimal.valueOf(3.0);
    System.out.println(b1.divide(b2, 2, RoundingMode.HALF_UP).multiply(b3)); // 0.990
    System.out.println(b1.multiply(b3).divide(b2, 2, RoundingMode.HALF_UP)); // 1.00

执行结果：

0.990
    1.00

执行顺序交换后，产生的结果可能不同，会导致一定的问题，使用顺序建议先乘后除。

一、BigDecimal概述  
Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。

一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。

BigDecimal所创建的是对象，故我们不能使用传统的+、-、\*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

二、BigDecimal常用构造函数  
2.1、常用构造函数

BigDecimal(int)
    创建一个具有参数所指定整数值的对象
    
    BigDecimal(double)
    创建一个具有参数所指定双精度值的对象
    
    BigDecimal(long)
    创建一个具有参数所指定长整数值的对象
    
    BigDecimal(String)
    创建一个具有参数所指定以字符串表示的数值的对象

2.2、使用问题分析  
使用示例：

BigDecimal a =new BigDecimal(0.1);
    System.out.println("a values is:"+a);
    System.out.println("=====================");
    BigDecimal b =new BigDecimal("0.1");
    System.out.println("b values is:"+b);

结果示例：

a values is:0.1000000000000000055511151231257827021181583404541015625
    =====================
    b values is:0.1

原因分析：

1）参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在Java中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。

2）String 构造方法是完全可预知的：写入 newBigDecimal(“0.1”) 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言， 通常建议优先使用String构造方法。

3）当double必须用作BigDecimal的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用Double.toString(double)方法，然后使用BigDecimal(String)构造方法，将double转换为String。要获取该结果，请使用static valueOf(double)方法。

三、BigDecimal常用方法详解  
3.1、常用方法

add(BigDecimal)
    BigDecimal对象中的值相加，返回BigDecimal对象
    
    subtract(BigDecimal)
    BigDecimal对象中的值相减，返回BigDecimal对象
    
    multiply(BigDecimal)
    BigDecimal对象中的值相乘，返回BigDecimal对象
    
    divide(BigDecimal)
    BigDecimal对象中的值相除，返回BigDecimal对象
    
    toString()
    将BigDecimal对象中的值转换成字符串
    
    doubleValue()
    将BigDecimal对象中的值转换成双精度数
    
    floatValue()
    将BigDecimal对象中的值转换成单精度数
    
    longValue()
    将BigDecimal对象中的值转换成长整数
    
    intValue()
    将BigDecimal对象中的值转换成整数

3.2、BigDecimal大小比较  
java中对BigDecimal比较大小一般用的是bigdemical的compareTo方法

int a = bigdemical.compareTo(bigdemical2)  
返回结果分析：

a = -1,表示bigdemical小于bigdemical2；
    a = 0,表示bigdemical等于bigdemical2；
    a = 1,表示bigdemical大于bigdemical2；
    举例：a大于等于b
    
    new bigdemica(a).compareTo(new bigdemical(b)) >= 0

四、BigDecimal格式化  
由于NumberFormat类的format()方法可以使用BigDecimal对象作为其参数，可以利用BigDecimal对超出16位有效数字的货币值，百分值，以及一般数值进行格式化控制。

以利用BigDecimal对货币和百分比格式化为例。首先，创建BigDecimal对象，进行BigDecimal的算术运算后，分别建立对货币和百分比格式化的引用，最后利用BigDecimal对象作为format()方法的参数，输出其格式化的货币值和百分比。

NumberFormat currency = NumberFormat.getCurrencyInstance(); //建立货币格式化引用
    NumberFormat percent = NumberFormat.getPercentInstance();  //建立百分比格式化引用
    percent.setMaximumFractionDigits(3); //百分比小数点最多3位
    
    BigDecimal loanAmount = new BigDecimal("15000.48"); //贷款金额
    BigDecimal interestRate = new BigDecimal("0.008"); //利率
    BigDecimal interest = loanAmount.multiply(interestRate); //相乘
    
    System.out.println("贷款金额:\t" + currency.format(loanAmount));
    System.out.println("利率:\t" + percent.format(interestRate));
    System.out.println("利息:\t" + currency.format(interest));
    结果：
    
    贷款金额: ￥15,000.48 利率: 0.8% 利息: ￥120.00
    BigDecimal格式化保留2为小数，不足则补0：

public class NumberFormat {
        
    
        public static void main(String[] s){
        
            System.out.println(formatToNumber(new BigDecimal("3.435")));
            System.out.println(formatToNumber(new BigDecimal(0)));
            System.out.println(formatToNumber(new BigDecimal("0.00")));
            System.out.println(formatToNumber(new BigDecimal("0.001")));
            System.out.println(formatToNumber(new BigDecimal("0.006")));
            System.out.println(formatToNumber(new BigDecimal("0.206")));
        }
        /**
         * @desc 1.0~1之间的BigDecimal小数，格式化后失去前面的0,则前面直接加上0。
         * 2.传入的参数等于0，则直接返回字符串"0.00"
         * 3.大于1的小数，直接格式化返回字符串
         * @param obj传入的小数
         * @return
         */
        public static String formatToNumber(BigDecimal obj) {
        
            DecimalFormat df = new DecimalFormat("#.00");
            if(obj.compareTo(BigDecimal.ZERO)==0) {
        
                return "0.00";
            }else if(obj.compareTo(BigDecimal.ZERO)>0&&obj.compareTo(new BigDecimal(1))<0){
        
                return "0"+df.format(obj).toString();
            }else {
        
                return df.format(obj).toString();
            }
        }
    }

结果为：

3.44
    0.00
    0.00
    0.00
    0.01
    0.21

五、BigDecimal常见异常  
5.1、除法的时候出现异常

java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result

原因分析：

通过BigDecimal的divide方法进行除法时当不整除，出现无限循环小数时，就会抛异常：java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.

解决方法：

divide方法设置精确的小数点，如：divide(xxxxx,2)

六、BigDecimal总结  
6.1、总结

> 在需要精确的小数计算时再使用BigDecimal，BigDecimal的性能比double和float差，在处理庞大，复杂的运算时尤为明显。故一般精度的计算没必要使用BigDecimal。  
> 尽量使用参数类型为String的构造函数。
> 
> BigDecimal都是不可变的（immutable）的， 在进行每一次四则运算时，都会产生一个新的对象  
> ，所以在做加减乘除运算时要记得要保存操作后的值。

6.2、工具类推荐

package com.vivo.ars.util;
    import java.math.BigDecimal;
    
    /**
     * 用于高精确处理常用的数学运算
     */
    public class ArithmeticUtils {
        
        //默认除法运算精度
        private static final int DEF_DIV_SCALE = 10;
    
        /**
         * 提供精确的加法运算
         *
         * @param v1 被加数
         * @param v2 加数
         * @return 两个参数的和
         */
    
        public static double add(double v1, double v2) {
        
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.add(b2).doubleValue();
        }
    
        /**
         * 提供精确的加法运算
         *
         * @param v1 被加数
         * @param v2 加数
         * @return 两个参数的和
         */
        public static BigDecimal add(String v1, String v2) {
        
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.add(b2);
        }
    
        /**
         * 提供精确的加法运算
         *
         * @param v1    被加数
         * @param v2    加数
         * @param scale 保留scale 位小数
         * @return 两个参数的和
         */
        public static String add(String v1, String v2, int scale) {
        
            if (scale < 0) {
        
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /**
         * 提供精确的减法运算
         *
         * @param v1 被减数
         * @param v2 减数
         * @return 两个参数的差
         */
        public static double sub(double v1, double v2) {
        
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.subtract(b2).doubleValue();
        }
    
        /**
         * 提供精确的减法运算。
         *
         * @param v1 被减数
         * @param v2 减数
         * @return 两个参数的差
         */
        public static BigDecimal sub(String v1, String v2) {
        
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.subtract(b2);
        }
    
        /**
         * 提供精确的减法运算
         *
         * @param v1    被减数
         * @param v2    减数
         * @param scale 保留scale 位小数
         * @return 两个参数的差
         */
        public static String sub(String v1, String v2, int scale) {
        
            if (scale < 0) {
        
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /**
         * 提供精确的乘法运算
         *
         * @param v1 被乘数
         * @param v2 乘数
         * @return 两个参数的积
         */
        public static double mul(double v1, double v2) {
        
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.multiply(b2).doubleValue();
        }
    
        /**
         * 提供精确的乘法运算
         *
         * @param v1 被乘数
         * @param v2 乘数
         * @return 两个参数的积
         */
        public static BigDecimal mul(String v1, String v2) {
        
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.multiply(b2);
        }
    
        /**
         * 提供精确的乘法运算
         *
         * @param v1    被乘数
         * @param v2    乘数
         * @param scale 保留scale 位小数
         * @return 两个参数的积
         */
        public static double mul(double v1, double v2, int scale) {
        
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return round(b1.multiply(b2).doubleValue(), scale);
        }
    
        /**
         * 提供精确的乘法运算
         *
         * @param v1    被乘数
         * @param v2    乘数
         * @param scale 保留scale 位小数
         * @return 两个参数的积
         */
        public static String mul(String v1, String v2, int scale) {
        
            if (scale < 0) {
        
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /**
         * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
         * 小数点以后10位，以后的数字四舍五入
         *
         * @param v1 被除数
         * @param v2 除数
         * @return 两个参数的商
         */
    
        public static double div(double v1, double v2) {
        
            return div(v1, v2, DEF_DIV_SCALE);
        }
    
        /**
         * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
         * 定精度，以后的数字四舍五入
         *
         * @param v1    被除数
         * @param v2    除数
         * @param scale 表示表示需要精确到小数点以后几位。
         * @return 两个参数的商
         */
        public static double div(double v1, double v2, int scale) {
        
            if (scale < 0) {
        
                throw new IllegalArgumentException("The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /**
         * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
         * 定精度，以后的数字四舍五入
         *
         * @param v1    被除数
         * @param v2    除数
         * @param scale 表示需要精确到小数点以后几位
         * @return 两个参数的商
         */
        public static String div(String v1, String v2, int scale) {
        
            if (scale < 0) {
        
                throw new IllegalArgumentException("The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v1);
            return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /**
         * 提供精确的小数位四舍五入处理
         *
         * @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 = new BigDecimal(Double.toString(v));
            return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /**
         * 提供精确的小数位四舍五入处理
         *
         * @param v     需要四舍五入的数字
         * @param scale 小数点后保留几位
         * @return 四舍五入后的结果
         */
        public static String round(String v, int scale) {
        
            if (scale < 0) {
        
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b = new BigDecimal(v);
            return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /**
         * 取余数
         *
         * @param v1    被除数
         * @param v2    除数
         * @param scale 小数点后保留几位
         * @return 余数
         */
        public static String remainder(String v1, String v2, int scale) {
        
            if (scale < 0) {
        
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /**
         * 取余数  BigDecimal
         *
         * @param v1    被除数
         * @param v2    除数
         * @param scale 小数点后保留几位
         * @return 余数
         */
        public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
        
            if (scale < 0) {
        
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
        }
    
        /**
         * 比较大小
         *
         * @param v1 被比较数
         * @param v2 比较数
         * @return 如果v1 大于v2 则 返回true 否则false
         */
        public static boolean compare(String v1, String v2) {
        
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            int bj = b1.compareTo(b2);
            boolean res;
            if (bj > 0)
                res = true;
            else
                res = false;
            return res;
        }
    }

[14df203aab9f4be0a8ffc8bf61668314.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/b01c3ec2f9f1486093fbcfa8a4172750.png