java计算器 中缀转后缀（不喜勿喷，没有毕业的时候写的）

public class InfixToSuffix {     static Stack<String> signStack = new Stack<String>();//存放运算符的S1    static Stack<String> middleResultStack = new Stack<String>();//存放中间结果的S2     public static Stack<String> getExpression(String Infix) {         System.out.println("(1) 初始化两个栈：运算符栈S1和储存中间结果的栈S2");         //从左至右扫描中缀表达式        System.out.println("(2)从左至右扫描中缀表达式");        for (int index = 0; index < Infix.length(); index++) {             if (Character.isUpperCase(Infix.charAt(index))) {                //遇到操作数时，将其压入S2                System.out.println("(3)遇到操作数时，将其压入S2   " + String.valueOf(Infix.charAt(index)));                middleResultStack.push(String.valueOf(Infix.charAt(index)));            } else {                 System.out.println("(4)遇到运算符时，比较其与S1栈顶运算符的优先级");                 if (signStack.isEmpty()) {                    //如果S1为空，则直接将此运算符入栈                    System.out.println("(4-1) 如果S1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈    " + String.valueOf(Infix.charAt(index)));                    signStack.push(String.valueOf(Infix.charAt(index)));                } else {                     //遇到运算符时，比较其与S1栈顶运算符的优先级                    char operator = Infix.charAt(index);                    switch (operator) {                    case '+' :                        getCompare(operator, 1);                        break;                    case '-' :                        getCompare(operator, 1);                        break;                    case '*' :                        getCompare(operator, 2);                        break;                    case '/' :                        getCompare(operator, 2);                        break;                    case '^' :                        getCompare(operator, 3);                        break;                    case 'g' :                        getCompare(operator, 4);                        break;                    case '(' :                        System.out.println("(5-1) 如果是左括号“(”，则直接压入S1");                        signStack.push(String.valueOf(Infix.charAt(index)));                        break;                    case ')' :                        //则依次弹出S1栈顶的运算符，并压入S2，直到遇到左括号为止，此时将这一对括号丢弃                        System.out.println("(5-2) 如果是右括号“)”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到左括号为止，此时将这一对括号丢弃");                        while (!signStack.peek().equals("(")) {                            middleResultStack.push(signStack.pop());                        }                        System.out.println("弹出左右括号");                        signStack.pop();                        break;                    default :                        System.out.println("奇怪" + String.valueOf(Infix.charAt(index)));                        //middleResultStack.push(String.valueOf(Infix.charAt(index)));                        break;                    }                }            }        }        System.out.println("(7) 将S1中剩余的运算符依次弹出并压入S2   S1 : " + signStack);        while (!signStack.isEmpty()) {            System.out.println("最后依次弹出S1中的符号    " + signStack.peek());            middleResultStack.push(signStack.pop());        }         return middleResultStack;    }     public static void getCompare(char ch, int prec1) {        while (!signStack.isEmpty()) {            String oper = signStack.peek();            int prec2 = -1;            if (oper.equals("+") || oper.equals("-")) {                prec2 = 1;            }else if (oper.equals("*") || oper.equals("/")) {                prec2 = 2;            } else if (oper.equals("^")) {                prec2 = 3;            } else if (oper.equals("g")) {                prec2 = 4;            }            //若优先级比栈顶运算符的高,也将运算符压入S1            if (prec1 > prec2 || oper.equals("(")) {                System.out.println("(4-2) 否则，若优先级比栈顶运算符的高，也将运算符压入S1（注意转换为前缀表达式时是优先级较高或相同，而这里则不包括相同的情况）   " + String.valueOf(ch));                signStack.push(String.valueOf(ch));                break;            } else {                //将S1栈顶的运算符弹出并压入到S2中,与S1中新的栈顶运算符相比较                System.out.println("(4-3) 否则，将S1栈顶的运算符弹出并压入到S2中，再次转到(4-1)与S1中新的栈顶运算符相比较1  "  + signStack.peek());                while (!signStack.isEmpty()) {                    middleResultStack.push(signStack.pop());                     if (!signStack.isEmpty()) {                        int prec3 = -1;                        if (signStack.peek().equals("+") || signStack.peek().equals("-")) {                            prec3 = 1;                        } else if (signStack.peek().equals("*") || signStack.peek().equals("/")) {                            prec3 = 2;                        } else if (signStack.peek().equals("^")) {                            prec3 = 3;                        } else if (signStack.peek().equals("g")) {                            prec3 = 4;                        }                         if (prec1 > prec3 || signStack.isEmpty() || signStack.peek().equals("(")) {                            System.out.println("(4-2) 否则，若优先级比栈顶运算符的高，也将运算符压入S1   " + String.valueOf(ch));                            signStack.push(String.valueOf(ch));                            break;                        } else {                            System.out.println("(4-3) 否则，将S1栈顶的运算符弹出并压入到S2中，再次转到(4-1)与S1中新的栈顶运算符相比较2   " + signStack.peek());                            middleResultStack.push(signStack.pop());                            if (signStack.isEmpty() || signStack.peek().equals("(")) {                                System.out.println("(4-1) 如果S1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈2  " + String.valueOf(ch));                                signStack.push(String.valueOf(ch));                                break;                            }                        }                    } else {                        signStack.push(String.valueOf(ch));                        break;                    }                }                break;            }        }    }     public static void main(String[] args) {        //A*D^B*(E+F*D+G*gD)^C        //A*D^B*((E+F*E^(G*D))^H)^C        //A*D^B*(E+F*D+G*gD)^C        Stack<String> a = getExpression("A+B+C");         Stack<String> b = new Stack<String>();              while (!a.isEmpty()) {            b.push(a.pop());        }        String h = "";        while (!b.isEmpty()) {            h += b.pop();        }        System.out.println("(8)依次弹出S2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式（转换为前缀表达式时不用逆序）");        System.out.println(h);    }}