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


}