java - 用栈实现四则运算(有括号)

整型10以下的加减乘除运算,多位数的四则运算可以自己去实现,浮点型计算,可以自己再改进

public class Calculation {
    private Stack<String> priStack = new Stack<String>();// 操作符栈
    
    static ArrayList<String> arr = new ArrayList<String>();    //后缀表达式
    int index = 0;
    
    public Calculation getCalculation(String str) {
        
        //StringBuffer tempNum = new StringBuffer();// 用来临时存放数字字符串(当为多位数时) --未实现      
        StringBuffer string = new StringBuffer().append(str);// 用来保存，提高效率
        
        while(string.length()!=0) {
            String ch = string.substring(0, 1);//取第一位
            string.delete(0, 1);//删除第一位
            if(isNum(ch)) {            //取到的是数字
                arr.add(ch);        //是数字时直接添加到后缀表达式
            }else {
                if(ch.equals("*") || ch.equals("/")) {    //乘除
                    while(!priStack.empty() && (priStack.peek().equals("*") || priStack.peek().equals("/"))) {    //栈不为空,栈里面乘除出栈,添加到后缀表达式
                        arr.add(priStack.pop());
                    }
                    priStack.push(ch);
                }else if(ch.equals("(") || ch.equals(")")){    //括号
                    if(ch.equals("(")) {                //左括号直接入栈
                        priStack.push(ch);
                    }else {                                //遇到右括号,出栈到遇到的第一个左括号
                        while(!priStack.empty() && !priStack.peek().equals("(")) {
                            arr.add(priStack.pop());
                        }
                        priStack.pop();        //左括号出栈
                    }
                }else {                        //加减
                    while(!priStack.empty() && !priStack.peek().equals("(")) {        //遇到加减,,有括号出栈到左括号(不包括左括号),没括号全部出栈
                        arr.add(priStack.pop());
                    }
                    priStack.push(ch);
                }
            }
        }
        return this;
    }
    
    /**   
              * 判断传入的字符是不是0-9的数字     
     * @param str   传入的字符串   
     * @return   
     */      
    private boolean isNum(String temp) {      
        return temp.matches("[0-9]");      //正则判断
    }
    
    private boolean isOperator(String temp) {
        return "+".equals(temp) || "-".equals(temp) || "*".equals(temp) || "/".equals(temp);
    }
    /**
         * 后缀表达式计算
         * @return    计算结果
     */
    private int compute() {
        for (int j = 0; j < arr.size(); j++) {
            if(isOperator(arr.get(j))) {
                ArrayList<Integer> arrNum = new ArrayList<Integer>();
                int a = j;    //第一个运算符位置
                do {
                    a--;
                    try {
                        if(isNum(arr.get(a))){
                            arrNum.add(Integer.valueOf(arr.get(a)));
                            arr.set(a, "!");
                        }
                    } catch (Exception e) {
                        e.printStackTrace();                       //后缀表达式异常
                    }
                    
                } while (arrNum.size()<2);
                int count = 0 ;
                switch (arr.get(j)) {
                case "+":
                    count = arrNum.get(1) + arrNum.get(0);
                    break;
                case "-":
                    count = arrNum.get(1) - arrNum.get(0);
                    break;
                case "*":
                    count = arrNum.get(1) * arrNum.get(0);
                    break;
                case "/":
                    count = arrNum.get(1) / arrNum.get(0);
                    break;
                }
                arr.set(j, count+"");
            }
        }
        return Integer.valueOf(arr.get(arr.size()-1));
    }
    
    public static void main(String[] args) {
        Calculation calculation = new Calculation();
        int i = calculation.getCalculation("1*((2+4)/(4-2)-2)=").compute();
        System.out.println(i);
    }
    
}