Java中BigDecimal工具类

曾经终败给现在 2022-12-17 05:29 235阅读 0赞

## 前言 ##

需要计算的场景绕不过去会使用BigDecimal类，可频繁的判空让代码可读性下降也使代码冗余度增高，不判空又容易报空指针异常，而且有些场景下的计算，结果为空时需要返回`null`，所以也不可以将将BigDecimal类型的值都初始化为0，会让运算结果产生歧义。为解决上述痛点，于是整理了一个工具类供所有项目一起使用。

# #

## 一.工具类支持功能 ##

1.  加减乘除、累加、倍数运算。
2.  `Integer、Long、Float、Double、String、Object`转为`BigDecimal`。
3.  除法四舍五入并默认保留20位小数点。
4.  `BigDecimal`转为`String`字符串，并禁止用科学计数法显示结果。
5.  小数点位数保留。
6.  多种数据类型间混合运算（如Double和Long转为BigDecimal运算）
7.  以上所有计算，支持所有入参为空时运算

import java.math.BigDecimal;
    
    /**
     * @description: BigDecimal运算工具类
     */
    public class DecimalUtils {
    
     /**
      * 加法计算（result = x + y）
      *
      * @param x 被加数（可为null）
      * @param y 加数 （可为null）
      * @return 和 （可为null）
      */
     public static BigDecimal add(BigDecimal x, BigDecimal y) {
      if (x == null) {
       return y;
      }
      if (y == null) {
       return x;
      }
      return x.add(y);
     }
    
     /**
      * 加法计算（result = a + b + c + d）
      *
      * @param a 被加数（可为null）
      * @param b 加数（可为null）
      * @param c 加数（可为null）
      * @param d 加数（可为null）
      * @return BigDecimal （可为null）
      */
     public static BigDecimal add(BigDecimal a, BigDecimal b, BigDecimal c, BigDecimal d) {
      BigDecimal ab = add(a, b);
      BigDecimal cd = add(c, d);
      return add(ab, cd);
     }
    
     /**
      * 累加计算(result=x + result)
      *
      * @param x      被加数（可为null）
      * @param result 和 （可为null,若被加数不为为null，result默认值为0）
      * @return result 和 （可为null）
      */
     public static BigDecimal accumulate(BigDecimal x, BigDecimal result) {
      if (x == null) {
       return result;
      }
      if (result == null) {
       result = new BigDecimal("0");
      }
      return result.add(x);
     }
    
     /**
      * 减法计算(result = x - y)
      *
      * @param x 被减数（可为null）
      * @param y 减数（可为null）
      * @return BigDecimal 差 （可为null）
      */
     public static BigDecimal subtract(BigDecimal x, BigDecimal y) {
      if (x == null || y == null) {
       return null;
      }
      return x.subtract(y);
     }
    
     /**
      * 乘法计算(result = x × y)
      *
      * @param x 乘数(可为null)
      * @param y 乘数(可为null)
      * @return BigDecimal 积
      */
     public static BigDecimal multiply(BigDecimal x, BigDecimal y) {
      if (x == null || y == null) {
       return null;
      }
      return x.multiply(y);
     }
    
     /**
      * 除法计算(result = x ÷ y)
      *
      * @param x 被除数（可为null）
      * @param y 除数（可为null）
      * @return 商 （可为null,四舍五入，默认保留20位小数）
      */
     public static BigDecimal divide(BigDecimal x, BigDecimal y) {
      if (x == null || y == null || y.compareTo(BigDecimal.ZERO) == 0) {
       return null;
      }
      // 结果为0.000..时，不用科学计数法展示
      return stripTrailingZeros(x.divide(y, 20, BigDecimal.ROUND_HALF_UP));
     }
    
     /**
      * 转为字符串(防止返回可续计数法表达式)
      *
      * @param x 要转字符串的小数
      * @return String
      */
     public static String toPlainString(BigDecimal x) {
      if (x == null) {
       return null;
      }
      return x.toPlainString();
     }
    
     /**
      * 保留小数位数
      *
      * @param x     目标小数
      * @param scale 要保留小数位数
      * @return BigDecimal 结果四舍五入
      */
     public static BigDecimal scale(BigDecimal x, int scale) {
      if (x == null) {
       return null;
      }
      return x.setScale(scale, BigDecimal.ROUND_HALF_UP);
     }
    
     /**
      * 整型转为BigDecimal
      *
      * @param x(可为null)
      * @return BigDecimal (可为null)
      */
     public static BigDecimal toBigDecimal(Integer x) {
      if (x == null) {
       return null;
      }
      return new BigDecimal(x.toString());
     }
    
     /**
      * 长整型转为BigDecimal
      *
      * @param x(可为null)
      * @return BigDecimal (可为null)
      */
     public static BigDecimal toBigDecimal(Long x) {
      if (x == null) {
       return null;
      }
      return new BigDecimal(x.toString());
     }
    
     /**
      * 双精度型转为BigDecimal
      *
      * @param x(可为null)
      * @return BigDecimal (可为null)
      */
     public static BigDecimal toBigDecimal(Double x) {
      if (x == null) {
       return null;
      }
      return new BigDecimal(x.toString());
     }
    
     /**
      * 单精度型转为BigDecimal
      *
      * @param x(可为null)
      * @return BigDecimal (可为null)
      */
     public static BigDecimal toBigDecimal(Float x) {
      if (x == null) {
       return null;
      }
      return new BigDecimal(x.toString());
     }
    
     /**
      * 字符串型转为BigDecimal
      *
      * @param x(可为null)
      * @return BigDecimal (可为null)
      */
     public static BigDecimal toBigDecimal(String x) {
      if (x == null) {
       return null;
      }
      return new BigDecimal(x);
     }
    
     /**
      * 对象类型转为BigDecimal
      *
      * @param x(可为null)
      * @return BigDecimal (可为null)
      */
     public static BigDecimal toBigDecimal(Object x) {
      if (x == null) {
       return null;
      }
      BigDecimal result = null;
      try {
       result = new BigDecimal(x.toString());
      } catch (Exception e) {
       e.printStackTrace();
      }
      return result;
     }
    
     /**
      * 倍数计算，用于单位换算
      *
      * @param x        目标数(可为null)
      * @param multiple 倍数 (可为null)
      * @return BigDecimal (可为null)
      */
     public static BigDecimal multiple(BigDecimal x, Integer multiple) {
      if (x == null || multiple == null) {
       return null;
      }
      return DecimalUtils.multiply(x, toBigDecimal(multiple));
     }
    
     /**
      * 去除小数点后的0（如: 输入1.000返回1）
      *
      * @param x 目标数(可为null)
      * @return
      */
     public static BigDecimal stripTrailingZeros(BigDecimal x) {
      if (x == null) {
       return null;
      }
      return x.stripTrailingZeros();
     }
    }

public static void main(String[] args) {
      // 定义两个变量，进行运算
      BigDecimal a = new BigDecimal("100");
      BigDecimal b = new BigDecimal("3.14");
    
      // 加 a+b
      BigDecimal c1 = DecimalUtils.add(a, b);
      // 减 a-b
      BigDecimal c2 = DecimalUtils.subtract(a, b);
      // 乘 a*b
      BigDecimal c3 = DecimalUtils.multiply(a, b);
      // 除 a/b
      BigDecimal c4 = DecimalUtils.subtract(a, b);
    
      // 累加 sum = a + sum
      BigDecimal sum = null;
      sum = DecimalUtils.accumulate(a, sum);
    
      // 将变量a结果保留2位小数
      BigDecimal c5 = DecimalUtils.scale(a, 2);
    
      // 变量a的1000倍运算   a*1000
      BigDecimal c6 = DecimalUtils.multiple(a, 1000);
    
      //Integer、Long、Float、Double、String、Object转为BigDecimal。
      Object obj = 123;
      BigDecimal c7 = DecimalUtils.toBigDecimal(obj);
    
      // BigDecimal转为字符串
      String str = DecimalUtils.toPlainString(a);
    
      // 不同数据类型之间混合运算（如：Double类型除以Long类型）
      BigDecimal mixCalc = DecimalUtils.divide(DecimalUtils.toBigDecimal(1.23D),DecimalUtils.toBigDecimal(1234567L));
    
    
     }

## 二.大于等于、小于等于 ##

if(a.compareTo(b) == -1){
        System.out.println("a小于b");
    }
     
    if(a.compareTo(b) == 0){
        System.out.println("a等于b");
    }
     
    if(a.compareTo(b) == 1){
        System.out.println("a大于b");
    }
     
    if(a.compareTo(b) > -1){
        System.out.println("a大于等于b");
    }
     
    if(a.compareTo(b) < 1){
        System.out.println("a小于等于b");
    }