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);
    }
}