表达式计算器

package scan.util;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class CalcUtil {

    private static Pattern p = Pattern.compile("\\([\\d.+\\-*/]+\\)");

    private static List<Expression> subExpression(String expression) {
        Matcher matcher = p.matcher(expression);
        List<Expression> list = new ArrayList<>();
        while (matcher.find()) {
            list.add(new Expression(matcher.group(), matcher.start(), matcher.end()));
        }
        return list;
    }

    private static double minExpression(String expression) {
        if (expression.startsWith("(")) {
            expression = expression.substring(1);
        }
        if (expression.endsWith(")")) {
            expression = expression.substring(0, expression.length() - 1);
        }
        char[] s = expression.toCharArray();
        List<Double> numList = new ArrayList<>();
        List<Character> calcList = new ArrayList<>();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length; i++) {
            if (('+' == s[i] || '-' == s[i] || '*' == s[i] || '/' == s[i]) && i != 0 && sb.length() > 0) {
                numList.add(Double.parseDouble(sb.toString()));
                calcList.add(s[i]);
                sb = new StringBuilder();
            } else {
                sb.append(s[i]);
            }
        }
        numList.add(Double.parseDouble(sb.toString()));
        calcList(numList, calcList, "md");
        calcList(numList, calcList, "as");
        return numList.get(0);
    }

    private static void calcList(List<Double> numList, List<Character> calcList, String op) {
        while (numList.size() > 1) {
            int i = 0;
            boolean find = false;
            for (; i < calcList.size(); i++) {
                Double result = null;
                if ("md".equals(op)) {//乘除
                    if (calcList.get(i) == '*') {
                        result = numList.get(i) * numList.get(i + 1);
                    } else if (calcList.get(i) == '/') {
                        result = numList.get(i) / numList.get(i + 1);
                    }
                } else {//加减
                    if (calcList.get(i) == '+') {
                        result = numList.get(i) + numList.get(i + 1);
                    } else if (calcList.get(i) == '-') {
                        result = numList.get(i) - numList.get(i + 1);
                    }
                }
                if (result != null) {
                    numList.remove(numList.get(i + 1));
                    numList.remove(numList.get(i));
                    numList.add(i, result);
                    find = true;
                    break;
                }
            }
            if (find) {
                calcList.remove(i);
            } else {
                break;
            }
        }
    }

    private static double calc(String expression) {
        List<Expression> list = subExpression(expression);
        if (list.isEmpty()) {
            return minExpression(expression);
        }
        StringBuilder sb = new StringBuilder();
        Expression e = null;
        int from = 0;
        for (int i = 0; i < list.size(); i++) {
            e = list.get(i);
            sb.append(safeSub(expression, from, e.start));
            sb.append(minExpression(e.expression));
            from = e.end;
        }
        sb.append(safeSub(expression, e.end, expression.length()));
        return calc(sb.toString());
    }


    private static String safeSub(String expression, int start, int end) {
        if (start < 0 || end > expression.length() || start > end)
            return "";
        return expression.substring(start, end);
    }


    static class Expression {
        String expression;
        int start;
        int end;

        public Expression(String expression, int start, int end) {
            this.expression = expression;
            this.start = start;
            this.end = end;
        }
    }


    public static void main(String[] args) {
        String[] expr = {
                "(5*(4+2)+10)/(4+2*2)"
                , "((4*(3-(-1/-1)))/5)*9"
                , "((4*(3-(-1*-1)))/5)*9"
                , "((4*(3-(-1+-1)))/5)*9"
                , "((4*(3-(-1-1)))/5)*9"
        };
        for (String e : expr) {
            System.out.println(e + " = " + calc(e.replaceAll("\\s", "")));
        }
    }


}