中缀转后缀表达式

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

public class FinalExpression {
    public static int calculate(List<String> list)   //专用于处理后缀表达式的计算器
    {
        Stack<Integer> ints = new Stack<Integer>();
        int result=0;
        int num1;
        int num2;
        for (String item:list){
            if (item.matches("\\d+")){
                    ints.push(Integer.parseInt(item));
            }else {
                num2=ints.pop();
                num1=ints.pop();
                switch(item){
                   case "+" :
                        result=num1+num2;
                        break;
                    case "-" :
                        result=num1-num2;
                        break;
                    case "*" :
                        result=num1*num2;
                        break;
                        case "/" :
                        result=num1/num2;
                        break;
                        default:
                            throw  new RuntimeException("运算符有误");

                }
                ints.push(result);
            }
        }
        return result;
    }

    public static List<String> ToSuffixExpression(List<String> list) {  //中缀转后缀表达式
        Stack<String> strings = new Stack<>();
        ArrayList<String> arrayList = new ArrayList<>();
        for (String item:list)
        {
            if (item.matches("\\d+")){   //正则表达式
                arrayList.add(item);
            }else if (item.equals("(")){
                   strings.push("(");
            }else if (item.equals(")")) {
                while (strings.peek()!="(")
                {
                    arrayList.add(strings.pop());
                }
                strings.pop();
            }else if (item.equals("*")||item.equals("/"))
            {
                strings.push(item);
            }else {
                //当+ 或- 出现时至少会有一轮弹出栈的过程  有两种方法实现   1.确定优先级,来比较是否弹出   2.根据可能出现的情况分析
                if (strings.size()==0)
                {
                    strings.push(item);
                    continue;
                }
                if (strings.peek().equals("(")){   //当item是＋或-时,只有这两种情况可以直接压入栈中,
                    strings.push(item);                               //因为+-优先级小于*/且  优先级  小于或等于  都需要变换..
                }else {
                    //这里的while需要注意只有这两种情况下可以跳出循环,即每个运算符的直接上层不可容忍平级或高级的运算符(除括号外),唯一的终止途径就是空或(

                    while (!(strings.size()==0||strings.peek().equals("("))) {   //考虑到||运算符的特殊性,如果前一项的是true后面就不会再测试,
                        arrayList.add(strings.pop());                            //有时利用这一特征可以解决空指针问题
                    }
                    strings.push(item);
                }
            }

        }
        while (strings.size()!=0)
        {
            arrayList.add(strings.pop());
        }

     return arrayList;

    }

    public static List<String> ToInfixExpression(String expression) {       //将表达式中数字与符号分离的处理函数
        ArrayList<String> list = new ArrayList<>();
        String con = "";
        for (int i = 0; i < expression.length(); i++) {
            char temp = expression.charAt(i);
            if (expression.charAt(i) < '0' || expression.charAt(i) > '9') {
                list.add("" + expression.charAt(i));  //简单将char转换为string的方式
            } else {
                con += temp;
                //方法1:将多位数整体取出
                if (i + 1 == expression.length()) {
                    list.add(con);
                    con = "";
                } else {
                    if (expression.charAt(i + 1) < '0' || expression.charAt(i + 1) > '9') {
                        list.add(con);
                        con = "";
                    }
                }
            }

        }
        return list;

    }
}