栈：逆波兰表达式（后缀表达式）

输入一个逆波兰表达式（后缀表达式）

例如：(3+4)*5-6对应的后缀表达式就是3 4 + 5 * 6 -，

针对后缀表达式求值步骤如下：

　　a. 从左到右扫描，将3 和 4压入堆栈；

　　b. 遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；

　　c. 将5入栈；　

　　d. 接下来是*运算符，因此弹出5和7，计算出7*5=35，将35入栈；

　　e. 将6入栈；

　　最后是-运算符，计算出35-6的值，即29，由此得出最终结果。

代码如下

package com.jyj.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation {
    public static void main(String[] args) {
        //先定义给逆波兰表达式
        //(3+4)*5-6  =>  3 4 + 5 * 6 -
        //说明：为了方便，逆波兰表达式的数字和符号使用空格隔开
        String suffixExpression = "3 4 + 5 * 6 -";
        List<String> list = getListString(suffixExpression);
        System.out.println("list = "+list);
        
        int res = calculate(list);
        System.out.println("res = "+res);
    }
    
    //将逆波兰表达式 ，依次将数据和运算符  放入到ArrayList中
    public static List<String> getListString(String suffixExpression) {
        //分隔逆波兰表达式
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<String>();
        for(String ele:split) {
            list.add(ele);
        }
        return list;
    }
    
    //完成逆波兰表达式计算
    /**
     *  a.从左到右扫描，将3 和 4压入堆栈；
        b.遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
        c.将5入栈；
        d.接下来是*运算符，因此弹出5和7，计算出7*5=35，将35入栈；
        e.将6入栈；
        f.最后是-运算符，计算出35-6的值，即29，由此得出最终结果。
     */
    public static int calculate(List<String> list) {
        Stack<String> stack = new Stack<String>();
        //遍历
        for(String item : list) {
            //使用正则表达式来取出数
            if(item.matches("\d+")) { //匹配多位数
                //入栈
                stack.push(item);
            }else {
                //pop出两个数，并运算，再入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if(item.equals("+")) {
                    res = num1 + num2;
                } else if(item.equals("-")) {
                    res = num1 - num2;
                } else if(item.equals("*")) {
                    res = num1 * num2;
                } else if(item.equals("/")) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符有误");
                }
                //把res入栈
                stack.push(""+res);
            }
        }
        return Integer.parseInt(stack.pop());
    }
}

//编写一个类 Operation 可以返回一个运算符对应的优先级
class Operation {
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;
    public static int getValue(String operation) {
        int result = 0;
        switch(operation) {
        case "+":
            result = ADD;
            break;
        case "-":
            result = SUB;
            break;
        case "*":
            result = MUL;
            break;
        case "/":
            result = DIV;
            break;
        default:
//            throw new RuntimeException("运算符有误");
            System.out.println("运算符有误");
            break;
        }
        return result;
    }
}

以上。