Java 栈实现四则运算

Java 栈 四则运算

public class StackTest {
    
    private Stack<Character> oprStack = new Stack<Character>();
    private Stack<Integer>   numStack = new Stack<Integer>();
    
    public static void main(String[] args) {
        StackTest st = new StackTest();
        System.out.println(st.calc("3+4*((4*10-10/2)+5)#"));
    }
    
    /** 
     * 解析并计算
     * @param src
     * @return
     */
    public Integer calc(String src) {
        
        clear();
        int from = 0, to = 0;
        char[] cs = src.toCharArray();
        while(to < cs.length && from < cs.length) {
            boolean numORopr = isNum(cs[from]); // true:num  false:opr
            do{
                to ++;
            }while(to < cs.length && numORopr && isNum(cs[to]));
            if(numORopr){
                addNum(Integer.parseInt(new String(cs, from, to - from)));
            } else {
                addOpr(cs[from]);
            }
            from = to;
        }
        return numStack.pop();
    }
    
    /** 
     * 清除历史记录
     */
    public void clear() {
        
        oprStack.clear();
        numStack.clear();
    }
    
    private boolean isNum(char b) {
        
        return b <= '9' && b >= '0';
    }
    
    /** 
     * 入栈操作符
     * @param c
     */
    private void addOpr(Character c) {
        
        while (!oprStack.empty() && isNeedCalc(c)) {
            calcByStep();
        }
        if(c == ')') {
            oprStack.pop();
        } else if(c != '#') {
            oprStack.push(c);
        }
    }
    
    private boolean isNeedCalc(Character c) {
        
        Character last = oprStack.lastElement();
        if(c == '(' || last == '(') return false;
        if(c == '*' || c == '/') return last == '*' || last == '/';
        if(c == '#' || c == ')' || c == '+' || c== '-') return true;
        throw new IllegalArgumentException();
    }
    
    /** 
     * 入站操作数
     * @param i
     */
    private void addNum(Integer i) {
        
        numStack.push(i);
    }
    
    private Character calcByStep() {
        
        int second = numStack.pop();
        int first  = numStack.pop();
        char opr   = oprStack.pop();
        switch(opr) {
        case '+': numStack.push(first + second); break;
        case '-': numStack.push(first - second); break;
        case '*': numStack.push(first * second); break;
        case '/': numStack.push(first / second); break;
        }
        return opr;
    }
    
}