利用栈实现四则运算

import java.util.*;
public class Main {
    static Set<Character> brace = new HashSet<Character>();
   public static void main(String[] args) {
      Scanner cin = new Scanner(System.in);
      brace.add('{');
      brace.add('[');
      brace.add('(');
      //输入格式做处理
      String exp =cin.nextLine().replaceAll("(?<![0-9)}\\]])(?=-[0-9({\\[])","0")+"#";
      System.out.println(caclute(exp));
  }    
   private static int caclute(String exp){
      Stack<Integer> opStack = new Stack<Integer>();
      Stack<Character> otStack = new Stack<Character>();
      String num ="";//
      for(int i=0;i<exp.length();i++){
          //提取字符
         char c = exp.charAt(i);
         //如果是数字
         if(Character.isDigit(c)){
             num+=c;
         }else{  //如果不是数字
             if(!num.isEmpty()){
                 //如果字符串不为空，数字入栈 ,并清空
                int n = Integer.parseInt(num);
                num="";
                opStack.push(n);
             }
             //如果遇到"#" 退出循环
             if(c=='#'){
                break;
             }else if(c=='+' || '-'==c){
                 //如果是空栈 后者栈顶是左括号，则入栈
                 if(otStack.isEmpty() || brace.contains(otStack.peek())){
                      otStack.push(c);
                 }else {
                     //否则一直弹栈计算，直到栈为空，或者遇到正括号 再入栈
                      while(!otStack.isEmpty() && !brace.contains(otStack.peek())){
                          popAndCal(opStack,otStack);
                      }
                      otStack.push(c);
                 }
                
                
             }else if('*'==c || '/'==c){
                  //栈空 或者栈顶运算符优先级低 或者 栈顶为正括号
                 if(otStack.isEmpty() || otStack.peek()=='+' ||otStack.peek()=='-' || brace.contains(otStack.peek())){
                       otStack.push(c);
                 }else {
                    //否则一直做弹栈运算 直到遇到"*" 或者'/' 或者正括号 最后入栈
                    while(!otStack.isEmpty() && !(otStack.peek()=='+') &&!(otStack.peek()=='-') && !brace.contains(otStack.peek())){
                         popAndCal(opStack, otStack);
                    }
                     otStack.push(c);
                    
                 }
                
             }else {
                
               //如果是正括号就入栈
                 if(brace.contains(c)){
                    otStack.push(c);
                 }else{//如果是反括号 则一直出栈计算 直到遇到正括号为止
                     char r = getBrace(c);
                     while(otStack.peek()!=r){
                        popAndCal(opStack, otStack);
                     }
                     //最后弹出正括号
                     otStack.pop();
               
                    
                 }
                
             }
            
         }
      }
      while(!otStack.isEmpty()){
        popAndCal(opStack, otStack) ;
      }
      return opStack.pop();
       
     }
private static char getBrace(char c) {
     switch(c){
     case '}':
          return '{';
     case ']':
         return '[';
     case ')':
         return '(';
     }
    
    return '#';  
}
private static void popAndCal(Stack<Integer> opStack, Stack<Character> otStack) {
      int op2 = opStack.pop();
      int op1 = opStack.pop();
      char ot = otStack.pop();
      int res =0;
      switch(ot){
      case'+':
         res = op1+op2;
         break;
      case'-':
          res = op1-op2;
          break;
      case'*':
          res = op1*op2;
          break;
      case'/':
          res = op1/op2;
          break;
      }
    opStack.push(res);
   
 }
}