leetcode--Evaluate Reverse Polish Notation

Evaluate the value of an arithmetic expression in Reverse Polish Notation.

Valid operators are +, -, *, /. Each operand may be an integer or another expression.

Some examples:

  ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
  ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6

public class Solution{
    public int evalRPN(String[] tokens) {
        Stack<Integer> nums = new Stack<Integer>();
        HashSet<String> opers = new HashSet<String>();
        opers.add("+");
        opers.add("-");
        opers.add("/");
        opers.add("*");
        int length = tokens.length;
        for(int i = 0; i < length; ++i){
            if(opers.contains(tokens[i])){
                int b = nums.pop();
                int a = nums.pop();
                nums.push(doOpers(a, b, tokens[i]));
            }
            else
                nums.push(Integer.parseInt(tokens[i]));
        }
        return nums.pop();
    }

    //I used java 7.
    public int doOpers(int a , int b, String opers){
        int result = 0;
        switch(opers){
            case "+": result = a + b;
                         break;
            case "-": result = a - b;
                         break;
            case "*": result = a * b;
                         break;
            case "/": result = a / b;
                         break;
        }
        return result;
    }    
}

 Notice, we need to add the zero divisor Exception.

The following code takes the exception into account.

public class Solution {
    public int evalRPN(String[] tokens) {
        int result = 0;
        Stack<Integer> st = new Stack<Integer>();
        int len = tokens.length;
        for(int i = 0; i < len; ++i){
            if(!isOperator(tokens[i]))
                st.push(Integer.parseInt(tokens[i]));
            else{
                int b = st.pop();
                int a = st.pop();
                try{
                    st.push(doCalculations(a, b, tokens[i]));
                }
                catch (ArithmeticException e){
                    e.printStackTrace();
                }
            }
        }
        result = st.pop();
        return result;
    }

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

    public int doCalculations (int inta, int intb, String c){
        int result = 0;
        switch(c){
            case "+": result = inta + intb;
                      break;
            case "-": result = inta - intb;
                      break;
            case "*": result = inta * intb;
                      break;
            default:
                      break;                    
        }

        if(c.equals("/")){
            if(intb != 0)
                result = inta / intb;
            else
                throw new ArithmeticException("zero divisor!");
         }
        return result;
    }
}