Implementación del código de proceso de cálculo de expresión en polaco inverso

package org.structure.stack;

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

/**
 * 中缀表达式转化成后缀表达式，并计算表达式结果的值
 *
 * @author cjj_1
 * @date 2020-08-10 11:50
 */
public class ToSuffix4Optimize {
    
    
    public static void main(String[] args) {
    
    
        String expression ="25.9 +(6.1+7)*9";
        Stack<String> s1 = toSuffix(expression);
        //计算后缀表达式
        double d = caculate(s1);
        System.out.printf("%s="+d,expression);

    }

    /**
     * 计算栈中的后缀表达式
     * @param s1
     * @return
     */
    private static double caculate(Stack<String> s1) {
    
    
        String str;
        BigDecimal d1;
        BigDecimal d2;
        double res;
        Stack<String> stack = new Stack<String>();
        for (String s : s1) {
    
    
            str = s.intern();
            if(isOper(str)){
    
    
                d1 = new BigDecimal(stack.pop());
                d2 = new BigDecimal(stack.pop());
                switch (str){
    
    
                    case "+":
                        res=d2.add(d1).doubleValue();
                        stack.push(res+"");
                        break;
                    case "-":
                        res=d2.subtract(d1).doubleValue();
                        stack.push(res+"");
                        break;
                    case "*":
                        res=d2.multiply(d1).doubleValue();
                        stack.push(res+"");
                        break;
                    case "/":
                        res=d2.divide(d1).doubleValue();
                        stack.push(res+"");
                        break;
                    default:break;
                }
            }else {
    
    
                stack.push(s);
            }
        }
        return Double.valueOf(stack.pop());
    }

    //中缀表达式转化成后缀表达式
   public static Stack toSuffix(String expression){
    
    
       Stack<String> s1 = new Stack<>();//存数字
       Stack<String> s2 = new Stack<>();//存操作符

       //把表达式存储到list中
       List<String> expressionList = expressionToList(expression);
       //遍历List 转换成后缀表达式
       String str;
       for (int i =0;i<expressionList.size();i++){
    
    
           str  = expressionList.get(i).trim().intern();
           if("(" == str){
    
    
               s2.push(str);
           } else if(")" == str){
    
    
                while ("(" !=  s2.peek()){
    
    
                    String oper = s2.pop();
                    s1.push(oper);
                }
                s2.pop();
           }else if(isOper(str)){
    
    
                while (!s2.isEmpty()&&priority(s2.peek())>=priority(str)){
    
    
                    s1.push(s2.pop());
                }
                s2.push(str);
           }else{
    
    
               s1.push(str.trim());
           }
       }
       while (!s2.isEmpty()){
    
    
           s1.push(s2.pop());
       }
//       String[] arr = (String[]) s1.toArray();
//       System.out.println(arr);
//       arr.toString();
       s1.forEach(s->{
    
    
           System.out.print(s+",");
       });
       System.out.println(";");

       return s1;
   }

    private static List<String> expressionToList(String expression) {
    
    
        List<String> dlist = new ArrayList();
        double d;
        String num = "";
        String str ;
        for (int i =0;i<expression.length();i++){
    
    
            str  =String.valueOf(expression.charAt(i)).trim().intern();
            if(isOper(str) || str=="(" || str ==")"){
    
    
                if(!num.trim().equals(""))
                    dlist.add(num.trim());
                dlist.add(String.valueOf(expression.charAt(i)));
                 num = "";
                continue;
            }
            num += String.valueOf(expression.charAt(i));
        }
        dlist.add(num);
        return dlist;
    }
    private static Boolean isOper(String c) {
    
    
        c = c.trim().intern();
        if(c=="+"||c=="-"||c=="*"||c=="/")
            return Boolean.TRUE;
        return Boolean.FALSE;
    }
    /*
     * 比较操作符的优先级
     * @author cjj_1
     * @date 2020-08-06 11:50:31
     * @param oper
     * @return
     **/
    public static int priority(String oper){
    
    
        if(oper.equals("*") || oper.equals("/"))
            return 1;
        else if(oper.equals("+") || oper.equals("-"))
            return 0;
        else
            return  -1;
    }
}