1. 先将中缀表达式转为对应的List
    2. 再将中缀表达式对应的List转为后缀表达式
    1. //方法：将中缀表达式转成对应的List
    2.     public static List<String> toInfixExpressionList(String s){
    3.         //定义一个List，存放中缀表达式对应的内容
    4.         List<String> ls = new ArrayList();
    5.         int i = 0;//这时是一个指针，用于遍历中缀表达式字符串
    6.         String str;//对多位数拼接
    7.         char c;//没遍历到一个字符，就放入到c
    8.         do{
    9.             //如果c是一个非数字，就需要加入到list中
    10.             if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57){
    11.                 ls.add("" + c);
    12.                 i++;//i需要后移
    13.             }else {//如果是数字，需要考虑多位数
    14.                 str = "";//先将str置为"", '0'=48, '9'=57
    15.                 while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57){
    16.                     str += c;//拼接
    17.                     i++;
    18.                 }
    19.                 ls.add(str);
    21.             }
    22.         }while (i < s.length());
    24.         return ls;
    25.     }
    28.     //   即ArrayList[1,+,(,(,2,+,3,),*,4,),-,5] => ArrayList[1,2,3,+,4,*,+,5,-]
    29.     //方法：将得到的中缀表达式对应的list => 后缀表达式对应的List
    30.     public static List<String> parseSuffixExpression(List<String> ls){
    31.         //定义两个栈
    32.         Stack<String> s1 = new Stack<>();//符号栈
    33.         //因为s2这个栈，在整个转换过程中，没有pop操作，而且后面我们还要逆序输出
    34.         //因此比较麻烦，这里我们就不用栈了，直接使用List<String> s2
    35.         //Stack<String> s2 = new Stack<>();//储存中间结果的栈s2
    36.         ArrayList<String> s2 = new ArrayList<>();
    38.         //遍历ls
    39.         for (String item : ls){
    40.             //如果是一个数，加入s2
    41.             if (item.matches("\\d+")){//如果是一个数字（包含多位数）
    42.                 s2.add(item);
    43.             }else if (item.equals("(")){
    44.                 s1.push(item);
    45.             }else if (item.equals(")")){
    46.                 while (!s1.peek().equals("(")){//peek()，查看栈顶元素
    47.                     s2.add(s1.pop());
    48.                 }
    49.                 s1.pop();//！将s1中的（ 弹出，以此消除了一对括号。
    50.             }else {
    51.                 //当item的优先级小于等于s1栈顶运算符，将s1栈顶的运算符弹出并加入到s2中，再次转到上一步（4.1），
    52.                 // 与s1中新的栈顶运算符相比较
    53.                 //比较运算符优先级的方法Operation类中的getValue()
    54.                 while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)){
    55.                     s2.add(s1.pop());
    56.                 }
    57.                 //还需要将item压入栈
    58.                 s1.push(item);
    59.             }
    60.         }
    62.         //将s1中剩余的运算符弹出加入到s2中
    63.         while (s1.size() != 0){
    64.             s2.add(s1.pop());
    65.         }
    67.         return s2;//注意：因为存放到List，因此按顺序输出就是对应的后缀表达式
    69.     }