import java.util.*;
public class TTask2 {
    public static void main(String[] args){
        String exp = "(32.5 + 43)* 7 + (4 * 5)" ;
        SuffixExpression se = compile(exp);
        String result = se.execute();
        System.out.println("计算结果：" + result);
    }
    static SuffixExpression compile(String exp){
        //此处将中缀转后缀
        //将中缀字符串转字符数组
        char[] expAry = exp.toCharArray();
        System.out.println("中缀表达式转数组："+ Arrays.toString(expAry));
        List<Character> oplist = Arrays.asList('+', '-','*','/');
        Deque<String> stack = new LinkedList<>();//栈
        StringBuilder ele = new StringBuilder();
        List<String> suf = new ArrayList<>();//盛放后缀表达式
        enum Operator {
            ADDITION('+', 1),
            SUBTRACTION('-', 1),
            MULTIPLICATION('*', 2),
            DIVISION('/', 2);
        
            private final char symbol;
            private final int precedence;
        
            Operator(char symbol, int precedence) {
                this.symbol = symbol;
                this.precedence = precedence;
            }
            static Operator fromSymbol(char symbol){
                for (Operator operator: values()){
                    if (operator.symbol == symbol){
                        return operator;
                    }
                }
                throw new IllegalArgumentException("No enum constant with symbol: " + symbol);
            }
            public int getPrecedence() {
                return precedence;
            }
        }       
        for(int i =0;i<expAry.length;i++){
            //处理数字,然后放入后缀表达式                            
            if (Character.isDigit(expAry[i])){                
                for(;Character.isDigit(expAry[i])||expAry[i]=='.';){
                    ele.append(expAry[i]);                    
                    if(i<expAry.length-1&&(Character.isDigit(expAry[i+1])||expAry[i+1]=='.')){
                        i++;
                    }else{break;}
                }
                suf.add(ele.toString());                
                ele.setLength(0);                
            //遇到左括号就压入栈中
            }else if (expAry[i] == '('){
                stack.push(String.valueOf(expAry[i]));
            }
            //遇到右括号就弹出栈内元素装进后缀表达式
            else if (expAry[i] == ')'){                
                for(;!stack.peek().equals("(");){
                    suf.add(stack.pop());
                }
                stack.pop();}
            //运算符检测
            else if(oplist.contains(expAry[i])){
                //若栈为空，或者遇到“（”直接进栈
                if (stack.isEmpty()||stack.peek().equals("(")){
                    stack.push(String.valueOf(expAry[i]));                    
                }else {              
                    Operator op1 =  Operator.fromSymbol(expAry[i]);                   
                    Operator op2 =  Operator.fromSymbol(stack.peek().charAt(0));
                    int result = Integer.compare(op1.getPrecedence(), op2.getPrecedence());
                    if(result>0){
                    stack.push(String.valueOf(expAry[i]));       
                    }else{
                        suf.add(stack.pop());
                        if(!stack.isEmpty()&&oplist.contains(stack.peek().charAt(0))){
                            Operator op3 =  Operator.fromSymbol(stack.peek().charAt(0));
                            int r = Integer.compare(op1.getPrecedence(), op3.getPrecedence());
                        if (r==0){
                            suf.add(stack.pop());
                        }
                    } 
                    stack.push(String.valueOf(expAry[i]));
                    }   
                    }
            }
        }
        while(!stack.isEmpty()){
            suf.add(stack.pop());
        }
        String[] sufArray = suf.toArray(new String[0]);
        System.out.println("转换的后缀表达式："+ Arrays.toString(sufArray));
        return new SuffixExpression(sufArray);
    }
}
class SuffixExpression{
    private String[] sufArr;
    private Deque<String> exeStack = new LinkedList<>();//栈
    private List<String> oplist = Arrays.asList("+", "-","*","/");
    SuffixExpression(String[] suf){
        this.sufArr = suf;
    }
    String execute(){
        for(String n:sufArr){
            if(oplist.contains(n)){
                double num1 = Double.parseDouble(exeStack.pop());
                double num2 = Double.parseDouble(exeStack.pop());
                double res = 0;
                switch (n){
                    case "+":res = num2 + num1;break;
                    case "-":res = num2 - num1;break;
                    case "*":res = num2 * num1;break;
                    case "/":res = num2 / num1;break;
                }
                exeStack.push(Double.toString(res));
            }else{
                exeStack.push(n);
            }
        }
        return exeStack.peek();
    }
}