中缀表达式转后缀表达式并进行计算（10以内整数加减乘除）

代码：

package com.wangyq.datastructrue.calculator;

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Stack;

/**
 * 10以内整数加减乘除
 */
public class Calculator {
    public static void main(String[] args) {
        //要计算的公式
        //认为公式为正确的不需要校验
        String equation = "9+(3-1)*3+8/2";//19
        //存放拆分后的结果
        Queue queue = new ArrayDeque();
        //拆分公式，将中缀表达式转为后缀表达式
        resolution(equation, queue);
        System.out.println(queue);
        //[9, 3, 1, -, 3, *, +, 8, 2, /, +]
        //计算后缀表达式
        calculate(queue);
    }

    private static void calculate(Queue queue) {
        if (queue.isEmpty()) {
            return;
        }
        //存放计算结果
        Stack stack = new Stack();
        while (!queue.isEmpty()) {
            //去出要计算的数字活运算符
            String template = (String) queue.poll();
            //如果是运算符进行运算
            if (isTrue(template)) {
                int num1 = Integer.parseInt((String) stack.pop());
                int num2 = Integer.parseInt((String) stack.pop());
                stack.push(operation(num1, num2, template));
                //如果不是运算符直接放入到运算结果中等待运算
            } else {
                stack.push(template);
            }
        }
        System.out.println(stack);

    }

    /**
     * 两个数进行运算
     *
     * @param num1
     * @param num2
     * @param template
     * @return
     */
    private static String operation(int num1, int num2, String template) {
        int num = 0;
        if ("+".equals(template)) {
            num = num2 + num1;
        } else if ("-".equals(template)) {
            num = num2 - num1;
        } else if ("*".equals(template)) {
            num = num2 * num1;
        } else if ("/".equals(template)) {
            num = num2 / num1;
        }
        return String.valueOf(num);
    }

    /**
     * 中缀转后缀表达式
     *
     * @param equation
     * @param queue
     */
    private static void resolution(String equation, Queue queue) {
        //定义临时存储运算符的栈
        Stack stack = new Stack();
        for (int i = 0; i < equation.length(); i++) {
            String temp = equation.substring(i, i + 1);
            //如果“(”直接入栈
            if ("(".equals(temp)) {
                stack.push(temp);
                //如果“）”直接入栈，运算符出栈进入队列，直到遇到“（”，并去除“（”
            } else if (")".equals(temp)) {
                while (true) {
                    queue.add(stack.pop());
                    if ("(".equals(stack.peek())) {
                        stack.pop();
                        break;
                    }
                }

            } else if (isTrue(temp)) {
                //如果是普通运算符，将运算优先级大于等于他的从栈中取出加入到队列中，最后将当前运算符入栈
                while (true) {
                    if (!stack.isEmpty() && getPriority(temp) <= getPriority((String) stack.peek())) {
                        queue.add(stack.pop());
                    } else {
                        break;
                    }
                }
                stack.push(temp);

            } else {
                //如果是数字直接进入队列
                queue.add(temp);
            }
        }
        //将剩余的运算符加入到队列中
        if (!stack.isEmpty()) {
            while (!stack.isEmpty()) {
                queue.add(stack.pop());
            }
        }
    }

    private static int getPriority(String temp) {
        if ("+".equals(temp) || "-".equals(temp)) {
            return 1;
        } else if ("*".equals(temp) || "/".equals(temp)) {
            return 2;
        } else {
            return -1;
        }
    }

    private static boolean isTrue(String temp) {
        if ("+".equals(temp) || "-".equals(temp) || "*".equals(temp) || "/".equals(temp)) {
            return true;
        }
        return false;
    }
}

运算结果：
[9, 3, 1, -, 3, *, +, 8, 2, /, +]
[19]

计算结果为19；