利用栈的特性对一个表达式求值

package cn.my.stack;

import java.util.Stack;

/**
 * 利用栈的特性进行表达式求值
 *
 * @author zhu
 *
 */
public class ExpressionValue {

    // 定义一个操作数栈
    private static Stack<Integer> numberStack = new Stack<Integer>();
    // 定义一个操作符栈
    private static Stack<Character> operatorStack = new Stack<Character>();

    public static void main(String[] args) throws Exception {
        System.out.println(expGetValue());
    }

    /**
     * @param operator
     *            操作符
     * @return 操作符的优先级
     */
    public static int getPriority(char operator) {
        switch (operator) {
        case '*':
            return 2;
        case '/':
            return 2;
        case '+':
            return 1;
        case '-':
            return 1;
        case '#':
            return 0;
        }
        return 0;
    }

    /**
     * @param x
     * @param operator
     * @param y
     * @return 按指定操作符计算两个操作数的到的结果
     */
    public static int operate(Integer x, char operator, Integer y) {
        switch (operator) {
        case '*':
            return x * y;
        case '/':
            return x / y;
        case '+':
            return x + y;
        case '-':
            return x - y;
        }
        return 0;
    }

    /**
     * @return 表达是的值
     * @throws Exception
     */
    public static int expGetValue() throws Exception {
        // 定义要存储字符和操作符的变量
        char ch;
        char operator;
        // 存储操作数和结果的变量
        Integer x, y, result;
        // 初始化运算符集合
        String operators = "+ - * / #";
        // 栈初始化,在栈底压入表达式左边虚设的字符"#",用于以后判断计算是否结束
        operatorStack.push('#');
        // 读入一个字符
        ch = (char) System.in.read();
        // 如果字符不是"#"或者操作符栈的站顶元素不是"#"则继续
        while (ch != '#' || operatorStack.peek() != '#') {
            // 如果输入的字符不在操作符集合中
            if (!operators.contains(String.valueOf(ch))) {
                // 注意System.in.read()读入时，键盘上的任何一个键都会被当做时输入值，包括Enter,当我们按下Enter时，实际上发送了
                // 两个值一个回车\t,一个换行\n,所以在判断字符时要把这两个值滤去
                if (ch != '\n' && ch != '\r') {
                    // 把字符所代表的数值压入操作数栈
                    numberStack.push(Character.getNumericValue(ch));
                }
                // 再读入一个字符
                ch = (char) System.in.read();

            } else if (getPriority(ch) > getPriority(operatorStack.peek())) { // 如果新读入的操作符的优先级比操作符栈顶元素的优先级高
                if (ch != '\n' && ch != '\r') {
                    // 则把操作符压入操作符栈
                    operatorStack.push(ch);
                }
                // 在读入一个字符
                ch = (char) System.in.read();

            } else { // 如果新读入的操作符的优先级比操作符栈顶元素的优先级低
                // 弹出位于操作符栈顶端的操作符
                operator = operatorStack.pop();
                // 弹出两个操作数
                x = numberStack.pop();
                y = numberStack.pop();
                // 计算结果
                result = operate(y, operator, x);
                // 把中间结果压入操作数栈
                numberStack.push(result);
            }
        }
        // 最终操作数栈顶的元素就是表达式的值
        return numberStack.pop();
    }
}