Java BigDecimal 精确计算

开发过程中，如果我们需要精确计算的结果时，必须使用bigDecimal 类来操作。

BigDecimal 中常用的方法

1. 加 add(BigDecimal)

2. 减 subtract(BigDecimal)

3. 乘 multiply(BigDecimal)

4. 除 divide(BigDecimal,int) 注：精确到指定小数点，防止无法整除的情况

5. 比大小 compareTo(BigDecimal)

工具类

public class PrecisionComputingUtil {
    //默认除法运算精度
    private static final int DEF_DIV_SCALE = 4;

    /**
     * double 类型的加法运算
     *
     * @param num1
     * @param num2
     * @return 两个参数的和
     */
    public static double add(double num1, double num2) {
        BigDecimal b1 = new BigDecimal(Double.toString(num1));
        BigDecimal b2 = new BigDecimal(Double.toString(num2));
        return b1.add(b2).doubleValue();
    }

    /**
     * String 类型的加法运算
     *
     * @param num1
     * @param num2
     * @return 两个参数的和
     */
    public static BigDecimal add(String num1, String num2) {
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num2);
        return b1.add(b2);
    }

    /**
     * String 类型 精确到指定位数的加法运算
     *
     * @param num1
     * @param num2
     * @param scale 保留scale 位小数
     * @return 两个参数的和
     */
    public static String add(String num1, String num2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num2);
        return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * double 类型的减法运算
     *
     * @param num1
     * @param num2
     * @return 两个参数的差
     */
    public static double sub(double num1, double num2) {
        BigDecimal b1 = new BigDecimal(Double.toString(num1));
        BigDecimal b2 = new BigDecimal(Double.toString(num2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * String 类型 精确的减法运算。
     *
     * @param num1
     * @param num2
     * @return 两个参数的差
     */
    public static BigDecimal sub(String num1, String num2) {
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num2);
        return b1.subtract(b2);
    }

    /**
     * String类型 保留指定位数的减法运算
     *
     * @param num1
     * @param num2
     * @param scale 保留scale 位小数
     * @return 两个参数的差
     */
    public static String sub(String num1, String num2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num2);
        return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * double 类型的乘法运算
     *
     * @param num1
     * @param num2
     * @return 两个参数的积
     */
    public static double mul(double num1, double num2) {
        BigDecimal b1 = new BigDecimal(Double.toString(num1));
        BigDecimal b2 = new BigDecimal(Double.toString(num2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * String类型的乘法运算
     *
     * @param num1
     * @param num2
     * @return 两个参数的积
     */
    public static BigDecimal mul(String num1, String num2) {
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num2);
        return b1.multiply(b2);
    }

    /**
     * double 类型 保存指定位数的乘法运算
     *
     * @param num1
     * @param num2
     * @param scale 保留scale 位小数
     * @return 两个参数的积
     */
    public static double mul(double num1, double num2, int scale) {
        BigDecimal b1 = new BigDecimal(Double.toString(num1));
        BigDecimal b2 = new BigDecimal(Double.toString(num2));
        return round(b1.multiply(b2).doubleValue(), scale);
    }

    /**
     * String 类型 保留指定位数的乘法运算
     *
     * @param num1
     * @param num2
     * @param scale 保留scale 位小数
     * @return 两个参数的积
     */
    public static String mul(String num1, String num2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num2);
        return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

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

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

    /**
     * 除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入
     *
     * @param num1
     * @param num2
     * @param scale 表示需要精确到小数点以后几位
     * @return 两个参数的商
     */
    public static String div(String num1, String num2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num1);
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 小数位四舍五入处理
     *
     * @param num     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double num, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(num));
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 小数位四舍五入处理
     *
     * @param num     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static String round(String num, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(num);
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 取余数
     *
     * @param num1
     * @param num2
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static String remainder(String num1, String num2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num2);
        return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 取余数  BigDecimal
     *
     * @param num1
     * @param num2
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static BigDecimal remainder(BigDecimal num1, BigDecimal num2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        return num1.remainder(num2).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 比较大小
     *
     * @param num1
     * @param num2
     * @return 如果num1 大于num2 则 返回true 否则false
     */
    public static boolean compare(String num1, String num2) {
        BigDecimal b1 = new BigDecimal(num1);
        BigDecimal b2 = new BigDecimal(num2);
        int bj = b1.compareTo(b2);
        boolean res;
        if (bj > 0)
            res = true;
        else
            res = false;
        return res;
    }
}

int res = a.compareTo(b);
res = -1 ,  表示 a<b
res = 0 ,   表示 a=b
res = 1 ,   表示 a>b