java四则运算

public class Arithmetic implements Serializable {

    /** 描述 */

    private static final long serialVersionUID = 3661149212694931772L;

    protected static Logger LOG = Logger.getLogger(Arithmetic.class);

    public static double arithmetic(String exp) {
        String result = parseExp(exp).replaceAll("[\\[\\]]", "");
        return Double.parseDouble(result);
    }

    /**
     * 除法
     * @param number1    除数
     * @param number2    被除数
     * @param decimal    保留几位小数点
     * @return
     */
    public static double divide(String number1, String number2,
            Integer decimal) {
        double result = 0;
        try {
            if (null != number1 && !number1.equals("") || null != number2
                    && !number2.equals("")) {
                Double num1 = Double.valueOf(number1);
                Double num2 = Double.valueOf(number2);
                double res = num1 / num2;
                if(decimal > 0) {
                    result = decimalFormat(res, decimal);
                } else {
                    result = res;
                }
            }
        } catch (ArithmeticException ae) {
            LOG.error("对不起，除数为0！");
            result = 0;
        } catch (Exception e) {
            LOG.error("divide  error");
            result = 0;
        }
        return result;
    }

    /**
     * 保留小数点几位
     * @param result
     * @param decimal
     * @return
     */
    public static double decimalFormat(double result, Integer decimal) {
        BigDecimal bg = new BigDecimal(result);
        return bg.setScale(decimal, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
    
    /**
     * 解析计算四则运算表达式，例：2+((3+4)*2-22)/2*3 描述
     * @param expression
     * @return
     */
    public static String parseExp(String expression) {
        // String numberReg="^((?!0)\\d+(\\.\\d+(?<!0))?)|(0\\.\\d+(?<!0))$";
        expression = expression.replaceAll("\\s+", "").replaceAll("^\\((.+)\\)$", "$1");
//        String checkExp = "\\d";
        String minExp = "^((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))$";
        // 最小表达式计算
        if (expression.matches(minExp)) {
            String result = calculate(expression);
            return Double.parseDouble(result) >= 0 ? result : "[" + result + "]";
        }
        // 计算不带括号的四则运算
        String noParentheses = "^[^\\(\\)]+$";
        String priorOperatorExp = "(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
        String operatorExp = "(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
        if (expression.matches(noParentheses)) {
            Pattern patt = Pattern.compile(priorOperatorExp);
            Matcher mat = patt.matcher(expression);
            if (mat.find()) {
                String tempMinExp = mat.group();
                expression = expression.replaceFirst(priorOperatorExp, parseExp(tempMinExp));
            } else {
                patt = Pattern.compile(operatorExp);
                mat = patt.matcher(expression);
                if (mat.find()) {
                    String tempMinExp = mat.group();
                    expression = expression.replaceFirst(operatorExp, parseExp(tempMinExp));
                }
            }
            return parseExp(expression);
        }
        // 计算带括号的四则运算
        String minParentheses = "\\([^\\(\\)]+\\)";
        Pattern patt = Pattern.compile(minParentheses);
        Matcher mat = patt.matcher(expression);
        if (mat.find()) {
            String tempMinExp = mat.group();
            expression = expression.replaceFirst(minParentheses, parseExp(tempMinExp));
        }
        return parseExp(expression);
    }

    /**
     * 计算最小单位四则运算表达式（两个数字） 描述
     * @param exp
     * @return
     */
    public static String calculate(String exp) {
        exp = exp.replaceAll("[\\[\\]]", "");
        String number[] = exp.replaceFirst("(\\d)[\\+\\-\\*\\/]", "$1,").split(",");
        BigDecimal number1 = new BigDecimal(number[0]);
        BigDecimal number2 = new BigDecimal(number[1]);
        BigDecimal result = null;

        String operator = exp.replaceFirst("^.*\\d([\\+\\-\\*\\/]).+$", "$1");
        if ("+".equals(operator)) {
            result = number1.add(number2);
        } else if ("-".equals(operator)) {
            result = number1.subtract(number2);
        } else if ("*".equals(operator)) {
            result = number1.multiply(number2);
        } else if ("/".equals(operator)) {
            result = number1.divide(number2);
        }

        return result != null ? result.toString() : null;
    }

    public static void main(String[] args) {
//        System.out.println(Arithmetic.divide("0", "30", 0));
        System.out.println(arithmetic("2.2+((3+14)*2-22)/2*3.2"));
    }
    
}