逆波兰计算器

使用到 中缀以及后缀表达式来完成这个计算器

如果 不知道中缀 和 后缀是怎么计算结果的点击下面这两个链接进行查看
单独使用中缀表达式完成计算
使用后缀表达式完成计算

这里是使用上面两个链接的组合起来最终完整版

能够计算小数以及处理带括号的表达式优先级的问题

// 中缀表达式 转后缀表达式
public class InfixExpression {
    // 判断符号
    public static  Boolean isOper(char val){
        if(val=='*' || val=='/' ||val=='+' ||val =='-' || val=='(' || val ==')')
            return true;
        return false;
    }
    // 把中缀表达式放到List中
    public static List<String> expressionToList(String expression) {
        List<String> arr = new ArrayList<>();
        String num="";
/*
         // 只能添加整数
        for (int i = 0; i < expression.length(); ) {
            // 如果是字符直接添加进去
            if (expression.charAt(i) < 48 || expression.charAt(i) > 57) {
                arr.add(String.valueOf(expression.charAt(i)));
                i++;
            } else {
                num = "";
                // 处理多位数的情况 '0'>=48 -> '9'<=57
                while (i < expression.length() && expression.charAt(i) >= 48 && expression.charAt(i) <= 57) {
                    num += expression.charAt(i);
                    i++;
                }
                arr.add(num);
            }
        }*/
//       TODO 解决能添加小数问题
        for (int i =0 ;i <expression.length();i++){
           if(isOper(expression.charAt(i))){
               arr.add(String.valueOf(expression.charAt(i)));
           }else{
               num +=expression.charAt(i);
               if(i == expression.length()-1){
                   arr.add(num);
               }else{
                   if (isOper(expression.charAt(++i))){
                       arr.add(num);
                       num="";
                   }
                   i--;
               }
           }
        }
        return arr;
    }

    // 中缀 转 后缀
    public static List<String> parseSuffixExpression(List<String> list) {
        // 符号栈
        Stack<String> symbolStack = new Stack<>();
        // 存储 中间的结果不用到出栈的操作所以改用成List存储
        ArrayList<String> numList = new ArrayList<String>();

        for (String item : list) {
            if (item.matches("(\\d+\\.\\d+)") || item.matches("\\d+"))
                numList.add(item);
            /**
             * 如果是符号
             * 有以下几种情况
             *  如果栈空 直接入栈
             *    如果不为空先判断符号的情况 ：
             *    符号的优先级的大小以及是否有括号
             *    如果 遇到的是 "("直接入栈
             *    当遇到")"时从符号栈中一直弹栈并加入到数字表中，直到
             *    遇到"("为止，同时也把"("弹出来，不用加入到数字表中
             *    如果 当前的符号比栈顶的符号优先级高 直接入栈
             *    否则就是小于或者等于的情况
             *      循环栈顶符号弹出加入到数字表中 直到大于或者栈空为止
             *    再把当前的符号压栈到符号栈中
             */
            else if (item.equals("(")) {
                symbolStack.push(item);
            } else if (item.equals(")")) {
                do
                    numList.add(symbolStack.pop());
                 while (!symbolStack.peek().equals("("));
                // while 停止意味着 符号栈顶已经指向"("这个位置了 要把"("弹出并扔掉
                symbolStack.pop();
            } else {
                while (symbolStack.size() != 0 && priority(item) <= priority(symbolStack.peek()))
                    numList.add(symbolStack.pop());
                symbolStack.push(item);
            }
        }
        // 把所有的符号栈中的符号加入到numList中
        while (!symbolStack.isEmpty()) {
            numList.add(symbolStack.pop());
        }
        return numList;
    }

    // 判断优先级
    private static int priority(String operation) {
        if (operation.equals("+") || operation.equals("-"))
            return 1;
        else if (operation.equals("*") || operation.equals("/"))
            return 2;
        else
            return 0;
    }

}

// 逆波兰表达式 计算
public class PostfixExpression {

    //将一个逆波兰表达式，依次将数据和运算符放入到Arraylist中
    public static List<String> getListString(String suffisExpression) {
        String[] split = suffisExpression.split(" ");
        ArrayList<String> list = new ArrayList<>();
        for (String str : split) {
            list.add(str);
        }

        return list;
    }

    /**
     *  完成对逆波兰表达式 的运算
     *  从左至右扫描，将3和4压入堆栈
     *  遇到 + 运算符，因此弹出 4 和 3 （4位栈顶元素，3为次顶元素），计算出 3+4 的值 得7 再将7入栈；
     *  将 5 入栈
     *  接下来是 * 运算符，因此弹出 5 和  7 ，计算出7*5=35 将35入栈
     *  最后是运算符，计算出35-6的值，即29，由此得出最终结果
     *
     */
    public static Double calculate(List<String> list) {
        Stack<String> stack = new Stack<>();
        for (String item : list) {
            if (item.matches("\\d+") || item.matches("(\\d+\\.\\d+)")) {
                stack.push(item);
            } else {
                Double num1 = Double.parseDouble(stack.pop());
                Double num2 = Double.parseDouble(stack.pop());
                Double res = cal(num1, num2, item);
                try {
                    stack.push(String.valueOf(res));
                }catch (Exception e) {
                    System.out.println(e.getMessage());
                }
            }

        }
        //返回栈的最终结果
        return Double.parseDouble(stack.pop()) ;
    }

    private static Double cal(Double num1, Double num2, String item) {
        Double res =0d;
        switch (item) {
            case  "+":
                 res = num2 + num1;
                 break;
            case  "-":
                res = num2 - num1;
                break;
            case  "*":
                res = num2 * num1;
                break;
            case  "/":
                res = num2 / num1;
                break;
            default:
                throw  new RuntimeException("运算符有误！");
        }
        return  res;
    }
public class Min {
    public static void main(String[] args) {

        /**
         * 先完成将一个中缀表达式转成后缀表达式的功能
         * "1+(2+3)*4)-5" 转成 1 2 3 + 4 * 5-
         * 因为直接对str 进行操作不方便，因此 ，先将 "1+(2+3)*4)-5"转成对应的List
         * 即 "1+(2+3)*4)-5" => ArrayList[1, +, (, 2, +, 3, ), *, 4, ), -, 5]
         * 再将 得到的中缀表达式对应的List => 后缀表达式对应的List
         * ArrayList[1,+,(,2,+,3,),*,4,),-,5] => ArrayList[1,2,3,+,4,*,+,5,-]
         *
         * 先定义一个逆波兰表达式（后缀）进行测试结果是否正确
         * (3+4)*5-6 => "3 4 + 5 * 6 -"
         * 1、先将"3 4 + 5 * 6 -" => 放到ArrayList中
         * 2、将ArrayList 传递给一个方法，遍历ArrayList配合栈完成计算
         *
         */
   /*     String suffisExpression = "3 4 + 5 * 6 -";
        List<String> list = PostfixExpression.getListString(suffisExpression);
        int result = PostfixExpression.calculate(list);
        System.out.println(result);*/
        String expression = "1.34+((25+3.6789)*4)-5";
//        String expression = "1+((2+3)*4)-5";
        List<String> reList = InfixExpression.expressionToList(expression);
        System.out.println("中缀："+reList);
        List<String> res = InfixExpression.parseSuffixExpression(reList);
        System.out.println("后缀："+res);
        Double result = PostfixExpression.calculate(res);
        System.out.println("结果：" +result);
    }

  }

}