import java.util.Stack;
public class Calcu{
    Stack <Integer>num;
    Stack <String>exp;
    String expression="7+(8+2*2)/3-1=";
    public Calcu(){
        num=new Stack<Integer>();
        exp=new Stack<String>();
    }
    public void calculate(){
        char t;
        int s;
        int len=expression.length();
        for(int i=0;i<len;i++){
            t=expression.charAt(i);
            switch(t){
            case '-':
            case '+':if(!exp.empty()&& !exp.peek().equals("(") && !exp.peek().equals(")")){
                s=compute(exp.pop());
                num.push(s);
            } exp.push(String.valueOf(t));
            break;
            case '/':
            case '*':
                if(!exp.empty()&& exp.peek().equals("/")){
                    s=compute(exp.pop());
                    num.push(s);
                }else if(!exp.empty() && exp.peek().equals("*")){
                    s=compute(exp.pop());
                    num.push(s);
                }
                exp.push(String.valueOf(t));break;
            case '(':exp.push(String.valueOf(t));break;
            case ')':{
                while(!exp.peek().equals("(")){
                    s=compute(exp.pop());
                    num.push(s);
                }
                exp.pop();
                break;
            }
            case '=':{
                while(!exp.empty()){
                    s=compute(exp.pop());
                    num.push(s);
                }
                System.out.println(num.pop());
                break;
            }
            default:num.push(t-48);
        }
    }
}
    private int compute(String exp){
        int n2=num.pop();
        int n1=num.pop();
        switch(exp.charAt(0)){
        case '+':return n1+n2;
        case '-':return n1-n2;
        case '*':return n1*n2;
        case '/':return n1/n2;
        }
        return -1;
    }
    public static void main(String args[]){
        Calcu c=new Calcu();
        c.calculate();
    }
}

------解决方案--------------------

给你逆波兰式算法.经过测试


package expression;   
   
import java.io.*;   
import java.util.*;   
   
public class Expression {   
   private ArrayList expression = new ArrayList();// 存储中序表达式   
   
   private ArrayList right = new ArrayList();// 存储右序表达式   
   
   private String result;// 结果   
   
   // 依据输入信息创建对象，将数值与操作符放入ArrayList中   
   private Expression(String input) {   
       StringTokenizer st = new StringTokenizer(input, "+-*/()", true);   
       while (st.hasMoreElements()) {   
           expression.add(st.nextToken());   
       }   
   }   
   
   // 将中序表达式转换为右序表达式   
   private void toRight() {   
       Stacks aStack = new Stacks();   
       String operator;   
       int position = 0;   
       while (true) {   
           if (Calculate.isOperator((String) expression.get(position))) {   
               if (aStack.top == -1  
                       || ((String) expression.get(position)).equals("(")) {   
                   aStack.push(expression.get(position));   
               } else {   
                   if (((String) expression.get(position)).equals(")")) {   
                       if (!((String) aStack.top()).equals("(")) {   
                           operator = (String) aStack.pop();   
                           right.add(operator);   
                       }   
                   } else {   
                       if (Calculate.priority((String) expression