逆波兰式计算字符串公式

package t201401;

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

public class T1502 {
    
    /**
     * 优先级比较
     * @param operator1 比较值
     * @param operator2 被比较值
     * @return 小于等于返回false,大于返回true
     */
    static boolean comparePrior(String operator1, String operator2) {
        if("(".equals(operator2)) {
            return true;
        }
        if ("*".equals(operator1) || "/".equals(operator1)) {
            if ("+".equals(operator2) || "-".equals(operator2)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 转为后缀表达式:
     * 1、如果是"("直接压入stack栈。
      * 2、如果是")"，依次从stack栈弹出运算符加到数组newExpressionStrs的末尾，知道遇到"("；
      * 3、如果是非括号，比较扫描到的运算符，和stack栈顶的运算符。如果扫描到的运算符优先级高于栈顶运算符则，把运算符压入栈。否则的话，就依次把栈中运算符弹出加到数组newExpressionStrs的末尾，直到遇到优先级低于扫描到的运算符或栈空，并且把扫描到的运算符压入栈中。就这样依次扫描，知道结束为止。如果扫描结束，栈中还有元素，则依次弹出加到数组newExpressionStrs的末尾，就得到了后缀表达式。
     * @param expressionStrs
     * @return
     */
    static String[] toSuffixExpression(String[] expressionStrs) {
        //新组成的表达式
        List<String> newExpressionStrs = new ArrayList<String>();
        Stack<String> stack = new Stack<String>();
        for (int i = 0; i < expressionStrs.length; i++) {
            if ("(".equals(expressionStrs[i])) { // 如果是左括号,则入栈
                stack.push(expressionStrs[i]);
            } else if ("+".equals(expressionStrs[i]) || "-".equals(expressionStrs[i]) || "*".equals(expressionStrs[i]) || "/".equals(expressionStrs[i])) {
                if (!stack.empty()) { // 取出先入栈的运算符
                    String s = stack.pop();
                    if(comparePrior(expressionStrs[i], s)) { //如果栈值优先级小于要入栈的值,则继续压入栈
                        stack.push(s);
                    } else {  //否则取出值
                        newExpressionStrs.add(s);
                    }
                }
                stack.push(expressionStrs[i]);
            } else if (")".equals(expressionStrs[i])) { //如果是")",则出栈,一直到遇到"("
                while (!stack.empty()) {
                    String s = stack.pop();
                    if (!"(".equals(s)) {
                        newExpressionStrs.add(s);
                    } else {
                        break;
                    }
                }
            } else {
                newExpressionStrs.add(expressionStrs[i]);
            }
        }
        while (!stack.empty()) {
            String s = stack.pop();
            newExpressionStrs.add(s);
        }
        return newExpressionStrs.toArray(new String[0]);
    }

    public static void main(String[] args) {
        
        //要用的字符串表达式
        String expressionStr = "a+b/(a+a)+c";
        Map<String,Double> map = new HashMap<String,Double>();
        map.put("a", 1.0);
        map.put("b", 2.0);
        map.put("c", 3.0);
        
        
        // 分割成表达式数组
        String[] strs = expressionStr.split("");
        String[] newStrs = toSuffixExpression(strs);
        Stack<Double> stack = new Stack<Double>();
        Double cache;
        for (int i = 0; i < newStrs.length; i++) {
            if ("*".equals(newStrs[i])){
                stack.push(stack.pop()*stack.pop());
            }else if("/".equals(newStrs[i])){
                cache = stack.pop();
                stack.push(stack.pop()/cache);
            }else if("+".equals(newStrs[i])){
                stack.push(stack.pop()+stack.pop());
            }else if("-".equals(newStrs[i])){
                cache = stack.pop();
                stack.push(stack.pop()-cache);
            }else{
                stack.push(map.get(newStrs[i]));
            }
        }
        
        System.out.println(stack.pop());
    }

}