棧（經典應用逆波蘭表達式）

java中棧繼承了Vector，源碼很簡單，採用的是順序存儲結構。
實現棧：

import java.util.Arrays;

public class Stack {
    private Object[] elementData;
    private int size;

    public Stack() {
        this(10);
    }

    public Stack(int initialCapacity) {
        this.elementData = new Object[initialCapacity];
    }

    public int size() {
        return this.size;
    }

    public Object push(Object obj) {
        // 檢查表空間是否以滿
        check(size + 1);
        elementData[size++] = obj;
        return obj;
    }

    private void check(int minCapacity) {
        if (minCapacity - elementData.length < 0) {
            int oldCapactity = elementData.length;
            int newCapacity = oldCapactity << 1;
            elementData = Arrays.copyOf(elementData, newCapacity);
        }

    }

    public Object pop() {
        final Object last;
        last = elementData[size - 1];
        elementData[size - 1] = null;
        size--;
        return last;
    }

    public static void main(String[] args) {
        Stack s = new Stack();


    }

}

逆波蘭表達式：

package demo;

import java.util.Scanner;
import java.util.Stack;

public class Test {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        String input = scanner.nextLine();

        char[] data = input.toCharArray();

        StringBuilder sb = new StringBuilder();

        Stack<Character> ops = new Stack<>();
        Stack<Double> vals = new Stack<>();
        toPostfix(data, sb, ops);
        scanner.close();
        // 9+(3-1)*3+8/2
        calculate(sb, vals);
        System.out.println(sb.toString());
        System.out.println("----");
        System.out.println(vals.pop());

    }

    /**
     * @param sb
     * @param vals
     *            存後綴表達式的棧
     */
    public static void calculate(StringBuilder sb, Stack<Double> vals) {
        for (int i = 0; i < sb.length(); i++) {

            Character c = sb.charAt(i);

            System.out.println(c);
            // 將數字壓入棧
            if (getPriority(c) == 0) {

                vals.push(Double.valueOf(c.toString()));

            } else { // 彈出棧頂的元素，計算壓入棧
                Double top = vals.pop();
                Double second = vals.pop();
                double result = 0;
                if (c.equals('-'))
                    result = second - top;
                if (c.equals('+'))
                    result = second + top;
                if (c.equals('*'))
                    result = second * top;
                if (c.equals('/'))
                    result = second / top;
                vals.push(result);
            }
        }
    }

    /**
     * @param data
     *            輸入的數據
     * @param sb
     *            保存後綴表達式
     * @param ops
     *            存運算符的棧
     */
    public static void toPostfix(char[] data, StringBuilder sb, Stack<Character> ops) {
        int priority = 0;// 標記棧頂元素的優先級
        for (int i = 0; i < data.length; i++) {
            Character c = data[i];
            System.out.println(c);
            // 遇到右括號彈出棧頂運算符
            if (c.equals(')')) {
                Character popData = ops.pop();
                sb.append(popData);

            }
            // 如果是運算符
            if (getPriority(c) != 0) {
                // 比較棧頂運算符優先級，大於等於壓入棧，否則彈出全部
                if (getPriority(c) >= priority) {
                    ops.push(c);
                    priority = getPriority(c);

                } else {

                    while (!ops.isEmpty()) {
                        Character popData = ops.pop();
                        sb.append(popData);
                    }
                    // 將當前運算符壓入棧
                    ops.push(c);
                }

            } else if (!c.equals('(') && !c.equals(')')) {
                sb.append(c + ' ');
            }

        }
        // 將棧內所有剩餘的運算符彈出
        while (!ops.isEmpty()) {

            sb.append(ops.pop());
        }
    }

    /**
     * @param c
     * @return 返回運算符的優先級
     */
    private static int getPriority(char c) {

        switch (c) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;

        default:
            return 0;
        }

    }

}

只能輸入數字1-9，雙位數判斷沒有想通請大神指教