棧是一種常用資料結構，其特性是FILO（first in last out），其基本概念這裡不做介紹，相信都學過了。直接食用java中已經封裝好Stack<>類。

棧的效率：入棧出棧複雜度為O(1)，不需要比較和移動操作。

案例1：單詞逆序
比如，輸入alphago，要求逆向輸出其結果：ogahpla。可以用棧來解決這類問題。

 String word = "alphago";
        Stack<Character> stack = new Stack<Character>();
        for(int i=0;i<word.length();i++){
            stack.push(word.charAt(i));
        }
        /**
         * 這種寫法有bug，問題在哪？
         for(int i=0;i<stack.size();i++){
            Character c = stack.pop();
            System.out.print(c);
        }*/
 

        while(stack.size()!=0){
            System.out.print(stack.pop());
        }

案例2：分隔符匹配
比如有字串a{b[c(d)c]b}a,如何檢測其中的分隔符是一一對應的。用棧來實現也是最簡單的。
分析：檢測到字元直接不管，檢測到左分隔符入棧，檢測到右分隔符，從棧中彈出一個符號，如果匹配則繼續，如果不匹配或者沒有則報錯。若有沒有匹配的左分隔符也報錯。

public static void main(String[] args) {
        // TODO Auto-generated method stub
 

        String word = "a{b[c(d)c]b}a";
        int result = check(word);
        if(result==-1){
            System.out.println("match success");
        }else{
            System.out.println("match fail: index = "+result+",character is '"+word.charAt(result)+"'");
        }
    }
    /**
     * 匹配錯誤返回第一個不匹配的位置
     * 匹配正確則返回-1
    */
 

    private static int check(String word){
        Stack<Character> stack = new Stack<Character>();
        for(int i=0;i<word.length();i++){
            char ch = word.charAt(i);
            switch(ch){
            case '{':
            case '[':
            case '(':
                stack.push(ch);
                break;
            case '}':
            case ']':
            case ')':
                if(stack.isEmpty()){
                    return i;
                }else{
                    char p = stack.pop();
                    if((ch=='}' && p!='{') 
                            || (ch==']' && p!='[')
                            ||(ch==')' && p!='(')){
                        return i;
                    }
                }
                break;
            }
        }
        if(!stack.isEmpty()){
            char c = stack.get(0);
            return word.indexOf(c);
        }
        return -1;
    }

案例3：我覺得這個案例最經典了。如何計算表示式的值。
比如任意一個表示式(1+2*3)/7-1,如何計算出他的正確答案。

分析：這道題光用棧還不夠，需要清楚計算的方式
首先，得將中綴表示式變為字尾表示式。
然後，計算後序表示式的值。

1）中綴變字尾
首先借助一個樹型圖來理解中綴和字尾
在網上找了個圖，如下：

對這個二叉樹做一次中根遍歷（即根放在中間，從左到右），可以得到表示式3+2*9-6/4,也就是我們常見的表示式。所以算數表示式都是以中綴表示式出現的。同樣，我們可以得到他的字尾表示式，進行一次後跟遍歷（即根放在最後，從左到右），可以得到329*+64/-。這就是由中綴變字尾了。同理，我們的表示式畫個圖，然後也可以寫出字尾表示式。

程式實現可以利用棧，情況比較複雜分幾種來描述
a. 3+2*9-6/4，*號優先順序更高

b. 帶括號的表示式(1+2*3)/7-1

2）字尾表示式求值
為什麼要先變字尾？因為變成字尾的過程中可以處理掉括號，最後利用棧可以求值。比如329*+64/-，我們將所有數字壓入棧中，每次碰到符號，則彈出左運算元和右運算元，進行一次計算，然後迴圈這個過程，就可以算出整個表示式。

329*+64/-

如果是中綴表示式則無法完成這個過程，因為字尾表示式可以保證計算符號一定有兩個運算元在他前面。

假定都是個位數運算，這樣可以用String來獲取每個字元

/**
     * 獲取字尾表示式
     * 如果錯誤，返回null
     */
    private static String getPostfixExpression(String expression){
        StringBuilder sb = new StringBuilder();
        Stack<Character> stack = new Stack<Character>();
        for(int i=0;i<expression.length();i++){
            char c = expression.charAt(i);
            if(Character.isDigit(c)){  //數字直接輸出
                sb.append(c);
            }else if(c=='+' || c=='-'){
                if(stack.isEmpty()){
                    stack.push(c);
                }else{
                    //pop所有並輸出，如果遇到左括號則停止，把左括號重新入棧
                    while(!stack.isEmpty()){   //階段結束標誌1
                        char p1 = stack.pop();
                        if(p1!='('){
                            sb.append(p1);
                        }else{   //階段結束標誌2
                            stack.push(p1);
                            break;
                        }
                    }
                    stack.push(c);
                }
            }else if(c=='*'||c=='/'){
                if(stack.isEmpty()){
                    stack.push(c);
                }else{
                    char p = stack.pop();
                    if(p=='*'||p=='/'){
                        sb.append(p);
                        //pop所有並輸出，如果遇到左括號則停止，把左括號重新入棧
                        while(!stack.isEmpty()){   //階段結束標誌1
                            char p1 = stack.pop();
                            if(p1!='('){
                                sb.append(p1);
                            }else{   //階段結束標誌2
                                stack.push(p1);
                                break;
                            }
                        }
                        stack.push(c);
                    }else{
                        stack.push(p);
                        stack.push(c);
                    }
                }
            }else if(c=='('){  //左括號直接入棧
                stack.push(c);
            }else if(c==')'){
                //記錄是否遇到左括號
                boolean match = false;
                //pop所有並輸出，如果遇到左括號則停止，把左括號舍棄
                while(!stack.isEmpty()){   
                    char p = stack.pop();
                    if(p=='('){
                        match = true;
                        break;
                    }else{   
                        sb.append(p);
                    }
                }
                if(!match){
                    return null;
                }
            }else{   //有非法字元
                return null;
            }
        }
        //結束之後，剩下的出棧
        while(!stack.isEmpty()){   
            sb.append(stack.pop());
        }
        return sb.toString();
    }

/**
     * 計算表示式結果
     */
    private static float getResult(String expression){
        Stack<Float> stack = new Stack<Float>();

        for(int i=0;i<expression.length();i++){
            char c = expression.charAt(i);
            if(Character.isDigit(c)){  //數字入棧
                stack.push((float)(c-'0'));
            }else{  //過濾後剩下的肯定是計算符號
                if(stack.size()<2){
                    System.out.println("表示式不正確");
                    return 0;
                }else{
                    float rightNum = stack.pop();
                    float leftNum = stack.pop();
                    float result = 0;
                    switch(c){
                    case '+':
                        result = (leftNum+rightNum);
                        break;
                    case '-':
                        result = (leftNum-rightNum);
                        break;
                    case '*':
                        result = (leftNum*rightNum);
                        break;
                    case '/':
                        result = (leftNum/rightNum);
                        break;
                    }
                    stack.push(result);
                }
            }
        }

        return stack.pop();
    }