中缀表达式转后缀表达式

中缀转后缀

流程：
先遍历字符串，定义两个栈（也可以使用一个栈加一个数组，我这里使用的是一个数组）
如果是数字直接入数组。
如果是符号判断符号栈是否为空，如果空直接入栈。
否则和栈里面所有元素比较，只要栈顶元素优先级高于或等于当前字符将符号栈字符弹出并加入到数组中。直到栈顶元素优先级小于当前符号。再将当前元素入符号栈
遇到左括号直接入符号栈，遇到右括号遍历字符栈直到遇到左括号停止。并将字符栈里面的字符加入数组中（括号直接弹出不加入数组）
最后字符站会剩下一个字符，将他加入数组即可
现在数组中的元素就是后缀表达式（逆波兰表达式）

import javax.xml.crypto.dsig.spec.XSLTTransformParameterSpec;
import java.util.ArrayList;
import java.util.Stack;

public class Calc {
    public static void main(String[] args) {
        String str = "1+((2+3)*4)-5";
        ArrayList<String> strings = Calc.transformList(str);
        ArrayList<String> strings1 = Calc.countList(strings);
        Stack<String> num = new Stack();
        int num1 = 0;
        int num2 = 0;
        for (String s1 : strings1){
            if (!Calc.issymbol(s1)) {
                num.push(s1);
            }else {
                num1 = Integer.parseInt(num.pop());
                num2 = Integer.parseInt(num.pop());
                int yunsuan = Calc.yunsuan(num2, num1, s1);
                num.push(String.valueOf(yunsuan));
            }
        }
        System.out.println(num.peek());
    }
    public static int yunsuan(int nume1,int nume2, String s){
        switch (s){
            case "+":
                return nume1+nume2;
            case "-":
                return nume1 - nume2;
            case "*":
                return nume1 * nume2;
            case "/":
                return nume1 / nume2;
        }
        return 0;
    }
    public static ArrayList<String> transformList(String str){
        int temp = 0;
        ArrayList<String> strings = new ArrayList<String>();
        while (temp < str.length()){
            strings.add(String.valueOf( str.charAt(temp)));
            temp++;
        }
        return strings;
    }
    public static ArrayList<String> countList(ArrayList<String> stringLi){
        Stack<String> symbol = new Stack<>();
        ArrayList<String> number = new ArrayList<>();
        for (String str1 : stringLi){
            if(issymbol(str1)){
                if (symbol.isEmpty()){
                    symbol.push(str1);
                }else{
                    if (str1.equals("(")){
                        symbol.push(str1);
                    }else if(str1.equals(")")){
                        while (true){
                            if (symbol.isEmpty()){
                                break;
                            }
                            if (symbol.peek().equals("(")){
                                symbol.pop();
                                break;
                            }
                            number.add(symbol.pop());
                        }
                    }else{
                          while (true){
                              if (symbol.isEmpty()){
                                  symbol.push(str1);
                                  break;
                              }
                              if (Calc.prioriyt(symbol.peek()) < Calc.prioriyt(str1)){
                                  symbol.push(str1);
                                  break;
                              }
                              number.add(symbol.pop());
                          }
                    }
                }
            }else {
                number.add(str1);
            }
        }
        number.add(symbol.pop());
        return number;
    }
    public static boolean issymbol(String st){
        if (st.equals("+") || st.equals("-") || st.equals("*") || st.equals("/") || st.equals("(") || st.equals(")")){
            return true;
        }
        return false;
    }
    public static int prioriyt(String st){
        if (st.equals("+") || st.equals("-")){
            return 0;
        }else if(st.equals("*") || st.equals("/")){
            return 2;
        }else if(st.equals("(") || st.equals(")")){
            return -2;
        }
        return -1;
    }
}