使用java实现逆波运算

public class Example {

    public static void main(String[] arg) {
        Evaluate evaluate = new Evaluate();
        //原始输入4 + ( 15 / 5 )
        String input = "4 + ( 15 / 5 ) ";
        //生成计算结果
        String result = evaluate.startEvalute(input);
        System.out.println("\n显示计算结果\nresult = " + result);
    }
}

class Evaluate {

    private static String operators = "+-*/";

    public String startEvalute(String input) {
        //转成字符串数组
        //例如 "4 + ( 15 / 5 ) " ==》 "4"  "+"  "("  "15"  "/"  "5"  ")"
        String[] inputs = getArrays(input);
        //发转成逆波表示法的字符串数组：
        //例如 将"4"  "+"  "("  "15"  "/"  "5"  ")" ==》"4"  "15"  "5"  "/"  "+" 
        String[] inputs2 = getReverse(inputs);
        //获取计算结果
        return calculate(inputs2);
    }

    /**
     * **
     * 拆分字符串为数组 例如 "4 + ( 15 / 5 ) " ==》 "4" "+" "(" "15" "/" "5" ")"
     *
     * @param input 输入的运算式子
     * @return 拆分后的字符数组
     */
    private String[] getArrays(String input) {
        input = input.replaceAll(" ", "");
        ArrayList<String> list = new ArrayList<>();
        char[] val = input.toCharArray();
        int min = 0;
        int length = val.length;
        for (int i = 0; i < length; i++) {
            if (val[i] > '9' || val[i] < '0') {
                if (i != min) {
                    list.add(String.valueOf(val, min, i - min));
                    min = i;
                }
                list.add(String.valueOf(val, min, 1));
                min++;
            }
        }
        if (val[length - 1] <= '9' && val[length - 1] >= '0') {
            list.add(String.valueOf(val, min, length - min));
        }
        return (String[]) list.toArray(new String[list.size()]);
    }

    /**
     * 发转成逆波表示法的字符串数组 例如 将"4" "+" "(" "15" "/" "5" ")" ==》"4" "15" "5" "/" "+"
     *
     * @param origin 被逆转之前的字符数组
     * @return 被逆转之后的字符数组
     */
    public String[] getReverse(String[] origin) {
        Stack<String> operatorsSatck = new Stack<>();
        operatorsSatck.push("#");
        Stack<String> reversesStack = new Stack<>();
        String popStr;
        for (String val : origin) {
            if (!operators.contains(val) && !")".equals(val) && !"(".equals(val)) {
                reversesStack.push(val);
            } else if (val.equals("(")) {
                operatorsSatck.push("(");
            } else if (val.equals(")")) {
                while (!("(").equals(popStr = operatorsSatck.pop())) {
                    reversesStack.push(popStr);
                }
            } else {
                while (!(("(").equals(popStr = operatorsSatck.pop()) || (operatosLevel(popStr) < operatosLevel(val)))) {
                    reversesStack.push(popStr);
                }
                operatorsSatck.push(popStr);
                operatorsSatck.push(val);
            }
        }

        while (!("#").equals(popStr = operatorsSatck.pop())) {
            reversesStack.push(popStr);
        }
        int count = reversesStack.size();
        String[] result = new String[count];
        for (int i = --count; i >= 0; i--) {
            result[i] = reversesStack.pop();
        }
        return result;
    }

    /****
     * 判断运算等级
     * @param operand 运算符号 加 减 乘 除
     * @return 数算等级 #是-1，加或减是0，乘除是1 
     */
    public int operatosLevel(String operand) {
        if (operand.equals("#")) {
            return -1;
        } else if (operators.contains(operand)) {
            switch (operators.indexOf(operand)) {
                case 0:
                case 1:
                    return 0;
                case 2:
                case 3:
                    return 1;
                default:
                    throw new RuntimeException("不可能出现的错误");
            }
        } else {
            throw new RuntimeException("不正确的运算符");
        }
    }

    /**
     * 输入逆波式
     * @param inputs 逆波式
     * @return 运算结果
     */
    private String calculate(String[] inputs) {

        Stack<String> stack = new Stack<String>();
        for (String input : inputs) {
            if (operators.contains(input)) {
                double n2 = Double.valueOf(stack.pop());
                double n1 = Double.valueOf(stack.pop());
                switch (operators.indexOf(input)) {
                    case 0:
                        stack.push(String.valueOf(n1 + n2));
                        break;
                    case 1:
                        stack.push(String.valueOf(n1 - n2));
                        break;
                    case 2:
                        stack.push(String.valueOf(n1 * n2));
                        break;
                    case 3:
                        stack.push(String.valueOf(n1 / n2));
                        break;
                }
            } else {
                stack.push(input);
            }
        }
        return stack.pop();
    }
}