java 运算工具类 BigDecimal

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 运算操作工具类
 */
public class OperationUtils {
    private static int SCALE = 13;

    enum operator {
        add('+'),
        subtract('-'),
        multiply('*'),
        divide('/');
        private char operator;

        operator(char operator) {
            this.operator = operator;
        }
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1
     * @param v2
     * @return 两个参数的和
     */
    public static String add(String v1, String v2) {
        return operation(v1, v2, operator.add).toString();
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1
     * @param v2
     * @return 两个参数的和
     */
    public static String add(double v1, double v2) {
        return add(Double.toString(v1), Double.toString(v2));
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1
     * @param v2
     * @return 两个参数的差
     */
    public static String subtract(String v1, String v2) {
        return operation(v1, v2, operator.subtract).toString();
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1
     * @param v2
     * @return 两个参数的差
     */
    public static String subtract(double v1, double v2) {
        return subtract(Double.toString(v1), Double.toString(v2));
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1
     * @param v2
     * @return 两个参数的积
     */
    public static String multiply(String v1, String v2) {
        BigDecimal decimal1 = new BigDecimal(v1);
        BigDecimal decimal2 = new BigDecimal(v2);
        return operation(v1, v2, operator.multiply).toString();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static String multiply(double v1, double v2) {
        return multiply(Double.toString(v1), Double.toString(v2));
    }


    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入。
     *
     * @param v1
     * @param v2
     * @return 两个参数的商
     */
    public static String divide(String v1, String v2) {
        if (v2.compareTo("0") < 0 || v2.compareTo("0") == 0) {
            throw new IllegalArgumentException("The divisor must be positive integer");
        }
        return operation(v1, v2, operator.divide).toString();
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入。
     *
     * @param v1
     * @param v2
     * @return 两个参数的商
     */
    public static String divide(double v1, double v2) {
        return divide(Double.toString(v1), Double.toString(v2));
    }

    /**
     * 返回计算的BigDecimal
     *
     * @param v1
     * @param v2
     * @param operator 运算符 + - * /
     */
    public static BigDecimal operation(String v1, String v2, OperationUtils.operator operator) {
        BigDecimal decimal1 = new BigDecimal(v1);
        BigDecimal decimal2 = new BigDecimal(v2);
        switch (operator) {
            case add:
                return decimal1.add(decimal2);
            case subtract:
                return decimal1.subtract(decimal2);
            case multiply:
                return decimal1.multiply(decimal2);
            case divide:
                //scale 表示需要精确到小数点以后几位。
                return decimal1.divide(decimal2, SCALE, RoundingMode.HALF_UP);
            default:
        }
        return null;
    }
}