java写中缀表达式转后缀表达式，并将转换后的结果输出

public class TestStack {

    //判断是否为操作符
    private static boolean isOperator(String oper){
        if(oper.equals("+") || oper.equals("-") || oper.equals("/") || oper.equals("*") || oper.equals("(") || oper.equals(")")){
            return true;
        }
        return false;

    }


    //计算操作符的优先级
    private static int priority(String s){
        switch (s){
            case "+" : return 1;
            case "-" : return 1;
            case "*" : return 2;
            case "/" : return 2;
            case "(" : return 3;
            case ")" : return 3;
            default : return 0;
        }

}

  

public static void bianli(List<String> list){
    Iterator iterator = list.iterator();
    while(iterator.hasNext()){
        String c = (String) iterator.next();
        System.out.print(c + " ");
    }
}

   //将中缀表达式转后缀表达式

 public static List<String> zhuanHuan(String[] data){
        List<String> list = new ArrayList<>();
        MyStack<String> fuHao = new MyStack<>();
        for(int i = 0;i < data.length;i++){
            if(isOperator(data[i])){
                //判断栈内是否为空，如果为空，直接进行存放
                if(fuHao.isEmpty()){
                    fuHao.push(data[i]);
                    continue;
                }else if("(".equals(data[i])){
                    fuHao.push(data[i]);
                    continue;
                }else if("(".equals(fuHao.peek()) && priority(fuHao.peek()) > priority(data[i]) ){  //如果准备进栈的符号小于栈顶的级别，并且栈顶的符号为'('
                    fuHao.push(data[i]);
                    continue;
                }else if(")".equals(data[i])){//如果准备进栈的符号为')'则从栈顶开始出栈
//                    List<Character> resultList = new ArrayList<>();
                    while(!"(".equals(fuHao.peek())){   //出栈直到下一个栈顶为'('
                        String c = fuHao.pop();
//                        resultList.add(c);
                        list.add(c);
                    }
                    /*
                    ListIterator<Character> iterator = resultList.listIterator(resultList.size());
                    while(iterator.hasPrevious()){
                        Character c = iterator.previous();
                        list.add(c);
                    }
                    */
                    fuHao.pop();    //之后将'('出栈
                    continue;

//                    符号的优先级大于栈顶符号的优先级，则将优先级高的输出,并将之后的数字先输出再输出符号
                }else if(priority(data[i]) > priority(fuHao.peek())){
                    String c1 = data[i];

                    //将准备入栈的后一个数字先输出
                    if(++i <= data.length - 1  && !isOperator(data[i])){
                        list.add(data[i]);
                    }
                    //入栈的优先级高则直接输出
                    list.add(c1);
                    continue;
                }else if(priority(data[i]) == priority(fuHao.peek())){
                    //入栈的时候判断前面是否有括号
                    Object[] characters = fuHao.getArr();
                    boolean temp = false;       //判断栈中是否有括号
                    for(int j = characters.length - 1;j >= 0;j--){
                        if("(".equals(characters[j])){
                            temp = true;
                        }
                    }
                    //有括号直接入栈
                    if(temp){
                        fuHao.push(data[i]);
                    }else {
                        //没有的话输出桟底的符号
                        list.add(fuHao.stackBottom());
                    }
                }
            }else{
                //数字的话直接输出
                list.add(data[i]);
                continue;
            }

        }
        list.add(fuHao.pop());
        bianli(list);

        return list;
    }

    //将转换后的表达式进行计算

public static void cal(String[] arr){
    Double sum = null;
    MyStack<Double> myStack = new MyStack<>();
    Pattern pattern = Pattern.compile("\\d+||(\\d+\\.\\d+)"); //使用正则表达式 匹配数字
    for(int i = 0;i < arr.length;i++){
        if ((pattern.matcher(arr[i])).matches()){   //如果匹配的是数字，则进栈
            myStack.push(Double.parseDouble(arr[i]));
        }else{
            Double d1 = myStack.pop();
            Double d2 = myStack.pop();
            sum = calSum(arr[i],d2,d1);
            myStack.push(sum);
        }
    }

    System.out.println("计算后的结果为:" + sum);

}

public static double calSum(String c,Double c1,Double c2){
    System.out.println("得到的表达式为:" + c1 + c + c2);
    Double sum;
    switch (c){
        case "+":
            sum = c1 + c2;
            break;
        case "-":
            sum = c1 - c2;
            break;
        case "*":
            sum = c1 * c2;
            break;
        case "/":
            sum = c1 / c2;
            break;
        default:sum=null;
    }
    return sum;
}

    //测试结果

    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        String input = s.next();
        String[] arr = input.split("");
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]  + ",");
        }
        List<String> list = zhuanHuan(input.split(""));
        String str = list.toString();
        String strr = str.substring(1,str.length() - 1);//去掉前后两个"[" "]"
        String[] str1 = strr.split(", ");
        cal(str1);
    }

｝

public class MyStack<T> {

    private T arr[];
    private int top;

    public T[] getArr() {
        return arr;
    }

    public void setArr(T[] arr) {
        this.arr = arr;
    }

    public int getTop() {
        return top;
    }

    public void setTop(int top) {
        this.top = top;
    }

    public MyStack(){
        top = -1;
        arr = (T[])new Object[10];
    }

    public MyStack(int maxSize){
        top = -1;
        arr = (T[]) new Object[maxSize];
    }

    //入栈操作 指针下移动
    public void push(T value){
        arr[++top] = value;
    }

    //推出元素并删除,指针下移
    public T pop(){
        int j = 10 - top - 1;
        T t = arr[top];

        System.arraycopy(arr,top + 1,arr,top,1);

//        for(int i = 0;i < arr.length;i++){
//            System.out.print(arr[i] + " ");
//
//        }
//        System.out.println();
        --top;
        return t;
    }

    //返回栈顶元素
    public T peek(){
        return arr[top];
    }

    //判断栈是否为空
    public boolean isEmpty(){
        return top == -1;
    }

    //判断栈是否满
    public boolean isFool(){
        return top == arr.length - 1;
    }

    //输出桟底的元素
    public T stackBottom(){
        if (!isEmpty()){
            return arr[0];
        }
        return null;
    }

    public T[] returnStack(){
        return arr;
    }

    public T peek1(){
        return arr[top - 1];
    }


}