思路

中缀表达式适合人类阅读和计算，但是对于计算机来说，后缀表达式更合适。先把中缀表达式转换为后缀表达式，然后就可以轻松计算出后缀表达式的结果。

代码

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.util.ArrayList;
  5. import java.util.Deque;
  6. import java.util.LinkedList;
  7. import java.util.List;
  9. public class Main {
  10.     public static void main(String[] args) throws IOException {
  11.         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
  12.         String expression = reader.readLine().trim();
  13.         List<String> infixList = infixToList(expression);
  14.         System.out.println(infixList);
  15.         List<String> postfixList = infixToPostfix(infixList);
  16.         System.out.println(postfixList);
  17.         int ans = calculate(postfixList);
  18.         System.out.println(ans);
  19.     }
  21.     /**
  22.      * 将中缀表达式的符号, 数字以List的形式存储
  23.      *
  24.      * @param expression 中缀表达式
  25.      * @return List
  26.      */
  27.     private static List<String> infixToList(String expression) {
  28.         List<String> ans = new LinkedList<String>();
  29.         char[] chars = expression.toCharArray();
  30.         for (int begin = 0, i = 0; i < chars.length; ) {
  31.             // 符号
  32.             if ((chars[i] < '0') || (chars[i] > '9')) {
  33.                 ans.add(chars[i] + "");
  34.                 ++i;
  35.                 begin = i;
  36.             } else { // 整字
  37.                 while ((i < chars.length) && (chars[i] >= '0') && (chars[i] <= '9')) {
  38.                     ++i;
  39.                 }
  40.                 ans.add(expression.substring(begin, i));
  41.                 begin = i;
  42.             }
  43.         }
  44.         return ans;
  45.     }
  47.     /**
  48.      * 中缀表达式数组转后缀表达式数组
  49.      *
  50.      * @param infixList 中缀表达式数组
  51.      * @return 后缀表达式数组
  52.      */
  53.     private static List<String> infixToPostfix(List<String> infixList) {
  54.         List<String> ans = new ArrayList<>(infixList.size());
  55.         // 符号栈
  56.         Deque<String> stack = new LinkedList<>();
  58.         for (String e : infixList) {
  59.             if (e.equals("(")) { // 左括号直接入栈
  60.                 stack.push(e);
  61.             } else if (e.equals(")")) { // 右括号入栈时, 一直出栈直到遇到将知道一个左括号
  62.                 while (!stack.peek().equals("(")) {
  63.                     // 栈顶元素出栈入队
  64.                     ans.add(stack.pop());
  65.                 }
  66.                 // 左括号直接出栈
  67.                 stack.pop();
  68.             } else if (isOperator(e)) { // 遇到操作符
  69.                 // 栈为空或者栈顶元素优先级低则入栈
  70.                 if (stack.isEmpty() || (getPriority(stack.peek()) < getPriority(e))) {
  71.                     stack.push(e);
  72.                 } else {
  73.                     // 栈不为空且栈顶元素不为左括号且栈顶元素优先级大于党员元素, 则持续出栈入队
  74.                     while ((!stack.isEmpty()) && (!stack.peek().equals("("))
  75.                             && (getPriority(stack.peek()) >= getPriority(e))) {
  76.                         ans.add(stack.pop());
  77.                     }
  78.                     stack.push(e);
  79.                 }
  80.             } else { // 遇到数字, 直接入队
  81.                 ans.add(e);
  82.             }
  83.         }
  84.         while (!stack.isEmpty()) {
  85.             ans.add(stack.pop());
  86.         }
  87.         return ans;
  88.     }
  90.     /**
  91.      * 判断s是否为操作符
  92.      *
  93.      * @param s 输入字符串
  94.      * @return s是操作符返回true, 否则返回false
  95.      */
  96.     private static boolean isOperator(String s) {
  97.         return s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/");
  98.     }
  100.     /**
  101.      * 栈中元素优先级
  102.      *
  103.      * @param s 字符串
  104.      * @return 该符号优先级
  105.      */
  106.     private static int getPriority(String s) {
  107.         switch (s) {
  108.             case "+":
  109.             case "-":
  110.                 return 1;
  111.             case "*":
  112.             case "/":
  113.                 return 2;
  114.         }
  115.         // 左括号优先级最低
  116.         return -1;
  117.     }
  119.     /**
  120.      * 后缀表达式求值
  121.      *
  122.      * @param list 后缀表达式数组
  123.      * @return 计算结果
  124.      */
  125.     private static int calculate(List<String> list) {
  126.         // 结果栈
  127.         Deque<Integer> stack = new LinkedList<>();
  128.         int num1, num2;
  129.         for (String e : list) {
  130.             if (isOperator(e)) {
  131.                 num2 = stack.pop();
  132.                 num1 = stack.pop();
  133.                 switch (e) {
  134.                     case "+":
  135.                         stack.push(num1 + num2);
  136.                         break;
  137.                     case "-":
  138.                         stack.push(num1 - num2);
  139.                         break;
  140.                     case "*":
  141.                         stack.push(num1 * num2);
  142.                         break;
  143.                     case "/":
  144.                         stack.push(num1 / num2);
  145.                         break;
  146.                 }
  147.             } else {
  148.                 stack.push(Integer.parseInt(e));
  149.             }
  150.         }
  151.         return stack.pop();
  152.     }
  153. }

参考

https://www.cnblogs.com/menglong1108/p/11619896.html