import java.util.StringTokenizer;
import java.util.Stack;

public class MyDC
{
    /** constant for addition symbol */
    private final char ADD = '+';
    /** constant for subtraction symbol */
    private final char SUBTRACT = '-';
    /** constant for multiplication symbol */
    private final char MULTIPLY = '*';
    /** constant for division symbol */
    private final char DIVIDE = '/';
    /** the stack */
    private Stack<Integer> stack;

    public MyDC() {
      stack = new Stack<Integer>();
    }

    public int evaluate (String expr)
    {
      int op1, op2, result = 0;
      String token;
      StringTokenizer tokenizer = new StringTokenizer (expr);

      while (tokenizer.hasMoreTokens()) {
            token = tokenizer.nextToken();

            //如果是运算符，调用isOperator
            if (isOperator(token)) {
                //从栈中弹出操作数2
                //从栈中弹出操作数1
                //根据运算符和两个操作数调用evalSingleOp计算result;
                //计算result入栈;
                op2 = (stack.pop()).intValue();
                op1 = (stack.pop()).intValue();
                //计算中间结果
                result = evalSingleOp(token.charAt(0),op1,op2);
                //将中间结果压入栈
                stack.push(new Integer(result));
            } else//如果是操作数
            //操作数入栈;
                stack.push(new Integer(Integer.parseInt(token)));

        }

      return result;
    }

    private boolean isOperator (String token)
    {
      return ( token.equals("+") || token.equals("-") ||
               token.equals("*") || token.equals("/") );
    }

    private int evalSingleOp (char operation, int op1, int op2)
    {
      int result = 0;

      switch (operation)
      {
        case ADD:
          result = op1 + op2;
          break;
        case SUBTRACT:
          result = op1 - op2;
          break;
        case MULTIPLY:
          result = op1 * op2;
          break;
        case DIVIDE:
          result = op1 / op2;
      }

      return result;
    }
}