加减乘除计算工具类

一、加法

    /**
     * 加法运算
     *
     * @param a 加数
     * @return
     */
    public static double add(double... a) {
        double result = 0D;
        int len = a.length;
        if (len == 1) {
            result = a[0];
        }
        if (len >= 2) {
            BigDecimal b1 = new BigDecimal(Double.toString(a[0]));
            BigDecimal b2 = new BigDecimal(Double.toString(a[1]));
            result = b1.add(b2).doubleValue();
        }
        if (len > 2) {
            for (int i = 2; i < len; i++) {
                double v = a[i];
                BigDecimal b1 = new BigDecimal(Double.toString(result));
                BigDecimal b2 = new BigDecimal(Double.toString(v));
                result = b1.add(b2).doubleValue();
            }
        }
        return result;
    }

二、减法

    /**
     * 减法运算
     *
     * @param s 减数
     * @return
     */
    public static double sub(double... s) {
        double result = 0D;
        int len = s.length;
        if (len == 1) {
            result = s[0];
        }
        if (len >= 2) {
            BigDecimal b1 = new BigDecimal(Double.toString(s[0]));
            BigDecimal b2 = new BigDecimal(Double.toString(s[1]));
            result = b1.subtract(b2).doubleValue();
        }
        if (len > 2) {
            for (int i = 2; i < len; i++) {
                double v = s[i];
                BigDecimal b1 = new BigDecimal(Double.toString(result));
                BigDecimal b2 = new BigDecimal(Double.toString(v));
                result = b1.subtract(b2).doubleValue();
            }
        }
        return result;
    }

三、乘法

    /**
     * 乘法运算
     *
     * @param m 乘数
     * @return 保留两个小数
     */
    public static double mul(double... m) {
        double result = 0D;
        int len = m.length;
        if (len == 1) {
            result = m[0];
        }
        if (len >= 2) {
            BigDecimal b1 = new BigDecimal(Double.toString(m[0]));
            BigDecimal b2 = new BigDecimal(Double.toString(m[1]));
            if (len == 2) {//两个参数直接返回保留小数点后2位数
                result = b1.multiply(b2).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            } else {//大于两个参数，为减少误差，保留小数点后5位数
                result = b1.multiply(b2).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
            }
        }
        if (len > 2) {
            for (int i = 2; i < len; i++) {
                double v = m[i];
                BigDecimal b1 = new BigDecimal(Double.toString(result));
                BigDecimal b2 = new BigDecimal(Double.toString(v));
                if (i == len - 1) {//若为最后一个参数，则返回保留小数点后2位数
                    result = b1.multiply(b2).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
                } else {//非最后一个参数，为减少误差，保留小数点后5位数
                    result = b1.multiply(b2).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
                }
            }
        }
        return result;
    }

    /**
     * 乘法运算
     *
     * @param scale 精确小数点后几位
     * @param m     乘数
     * @return 保留scale个小数
     */
    public static double mul(int scale, double... m) {
        double result = 0D;
        int len = m.length;
        if (len == 1) {
            result = m[0];
        }
        if (len >= 2) {
            BigDecimal b1 = new BigDecimal(Double.toString(m[0]));
            BigDecimal b2 = new BigDecimal(Double.toString(m[1]));
            if (len == 2) {//两个参数直接返回保留小数点后scale位数
                result = b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
            } else {//大于两个参数，为减少误差，保留小数点后scale+3位数
                result = b1.multiply(b2).setScale(scale + 3, BigDecimal.ROUND_HALF_UP).doubleValue();
            }
        }
        if (len > 2) {
            for (int i = 2; i < len; i++) {
                double v = m[i];
                BigDecimal b1 = new BigDecimal(Double.toString(result));
                BigDecimal b2 = new BigDecimal(Double.toString(v));
                if (i == len - 1) {//若为最后一个参数，则返回保留小数点后scale位数
                    result = b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
                } else {//非最后一个参数，为减少误差，保留小数点后scale+3位数
                    result = b1.multiply(b2).setScale(scale + 3, BigDecimal.ROUND_HALF_UP).doubleValue();
                }
            }
        }
        return result;
    }

四、除法

    /**
     * 除法运算
     *
     * @param d 除数
     * @return 保留两个小数
     */
    public static double div(double... d) {
        double result = 0D;
        int len = d.length;
        if (len == 1) {
            result = d[0];
        }
        if (len >= 2) {
            BigDecimal b1 = new BigDecimal(Double.toString(d[0]));
            BigDecimal b2 = new BigDecimal(Double.toString(d[1]));
            if (len == 2) {//两个参数直接返回保留小数点后2位数
                result = b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP).doubleValue();
            } else {//大于两个参数，为减少误差，保留小数点后5位数
                result = b1.divide(b2, 5, BigDecimal.ROUND_HALF_UP).doubleValue();
            }
        }
        if (len > 2) {
            for (int i = 2; i < len; i++) {
                double v = d[i];
                BigDecimal b1 = new BigDecimal(Double.toString(result));
                BigDecimal b2 = new BigDecimal(Double.toString(v));
                if (i == len - 1) {//若为最后一个参数，则返回保留小数点后2位数
                    result = b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP).doubleValue();
                } else {//非最后一个参数，为减少误差，保留小数点后5位数
                    result = b1.divide(b2, 5, BigDecimal.ROUND_HALF_UP).doubleValue();
                }
            }
        }
        return result;
    }

    /**
     * 除法运算
     *
     * @param scale 精确小数点后几位
     * @param d     除数
     * @return 保留scale个小数
     */
    public static double div(int scale, double... d) {
        double result = 0D;
        int len = d.length;
        if (len == 1) {
            result = d[0];
        }
        if (len >= 2) {
            BigDecimal b1 = new BigDecimal(Double.toString(d[0]));
            BigDecimal b2 = new BigDecimal(Double.toString(d[1]));
            if (len == 2) {//两个参数直接返回保留小数点后scale位数
                result = b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
            } else {//非最后一个参数，为减少误差，保留小数点后scale+3位数
                result = b1.divide(b2, scale + 3, BigDecimal.ROUND_HALF_UP).doubleValue();
            }
        }
        if (len > 2) {
            for (int i = 2; i < len; i++) {
                double v = d[i];
                BigDecimal b1 = new BigDecimal(Double.toString(result));
                BigDecimal b2 = new BigDecimal(Double.toString(v));
                if (i == len - 1) {//若为最后一个参数，则返回保留小数点后scale位数
                    result = b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
                } else {
                    result = b1.divide(b2, scale + 3, BigDecimal.ROUND_HALF_UP).doubleValue();
                }
            }
        }
        return result;
    }