中缀表达式转后缀表达式并计算

中缀表达式，类似于这种9+（3-1）3+10/2 = 20，然后转化成后缀表达式 931-3+10 2/+
通过后缀表达式进行计算得出结果
后缀表达式的计算过程为
931-3*+10 2/+
923*+10 2/ +
96+10 2/ +
15 10 2/ +
15 5 +
20
实现流程：
中缀表达式—>后缀表达式
先将数字输出，然后遇到括号或者是运算符，将括号和运算符压入栈，当遇到右括号时，在弹出栈中括号内的运算符，当优先级低的运算符想要入栈时，栈顶元素为优先级高的运算符，则先将优先级高的运算符弹出，直到栈内没有比当前运算符优先级高的运算符时，将当前运算符压入栈。当遍历完表达式时，弹出栈内剩余的运算符。
代码实现为：
`package stack;

import java.math.BigInteger;
import java.util.EmptyStackException;

public class Operation {

// 中缀表达式
String expression;

public Operation(String expression) {
    this.expression = expression;
}

/**
 * 将中缀表达式转化为后缀表达式
 * 
 * @return 后缀表达式
 */
String converNifixToSuffix() {
    // 保存操作符的栈
    MyStack operation = new MyStack<>();
    // 将中缀表达式的字符转化字符数组
    final char[] nifixExpression = this.expression.toCharArray();
    // 字符数组长度
    final int len = nifixExpression.length;
    // 保存后缀表达式的字符串
    String suffixExpression = "";
    // 记录数字的最大位数
    int flag = 0;
    for (int i = 0; i < len; i++) {

        char index = nifixExpression[i];
        // 如果是数字，输出
        if (isNum(index)) {
            // 如果遇见运算符，最大位数会重置
            if (flag == 0) {
                // suffixExpression[j++] = ' ';
                // 每个数字之间用空格区分
                suffixExpression += " ";
            }
            // 数字的最大位++
            flag++;
            // 输出数字
            suffixExpression += index;

            // 如果字符是括号或者是操作符
        } else if (isOperation(index) || isBracket(index)) {
            // maxNum = Math.max(maxNum,flag);
            flag = 0;
            if (index == ')') {
                // 弹出括号里所有的运算符
                while (!operation.isEmpty()) {
                    char ch = operation.pop();
                    if (ch == '(') {
                        break;
                    }
                    // 将括号里的运算符输出
                    suffixExpression += ch;
                }
                // 如果是操作符
            } else {
                // 通过判断优先级来弹出操作符和压入操作符
                if (index == '+' || index == '-') {
                    while (!operation.isEmpty() && index != '(') {
                        char c = operation.peek();
                        if (c == '+' || c == '-' || c == '*' || c == '/') {
                            suffixExpression += operation.pop();
                        } else {
                            break;
                        }
                    }
                    // 将操作符压入栈
                    operation.push(index);
                } else {
                    while (!operation.isEmpty() && index != '(') {
                        char c = operation.peek();
                        if (c == '*' || c == '/') {
                            suffixExpression += operation.pop();
                        } else {
                            break;
                        }
                    }
                    operation.push(index);
                }
            }
        }

    }
    // 表达式遍历完将运算符栈内的所有运算符输出
    while (!operation.isEmpty()) {
        suffixExpression += operation.pop();
    }
    // 返回后缀表达式
    return suffixExpression;
}

public BigInteger calculate() {
    BigInteger result = null;
    try {
        result = calculateSuffixExpression(this.converNifixToSuffix());
    } catch (EmptyStackException e) {
        System.out.println("中缀表达式不合法！");
    }
    return result;
}

BigInteger calculateSuffixExpression(String suffixExpression) throws EmptyStackException {
    MyStack number = new MyStack<>();
    final char[] suffixE = suffixExpression.toCharArray();
    final int len = suffixE.length;
    for (int i = 0; i < len; i++) {
        char index = suffixE[i];
        String temp = "";
        if (index == ' ') {
            int j = i + 1;

            while (suffixE[j] != ' ' && !isOperation(suffixE[j])) {

                temp += suffixE[j];
                j++;
            }

            number.push(new BigInteger(temp.trim()));
            // 更新指针
            i = j - 1;

        } else if (isOperation(index)) { // 如果是操作符

            BigInteger n1 = number.pop();// 弹出数字
            BigInteger n2 = number.pop();// 弹出数字
            BigInteger n = operate(n2, n1, index);// 计算结果
            number.push(n);// 压入栈

        }

    }
    // 最后的结果为栈顶元素
    return number.peek();
}

/**
 * 判断是否为数字
 * 
 * @param ch
 * @return
 */
boolean isNum(char ch) {
    final char c = ch;
    switch (c) {
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
        return true;
    default:
        return false;
    }
}

/**
 * 判断是否为括号
 * 
 * @param ch
 * @return
 */
boolean isBracket(char ch) {
    final char c = ch;
    if (c == '(' || c == ')') {
        return true;
    }
    return false;
}

/**
 * 判断是否为操作符
 * 
 * @param ch
 * @return
 */
boolean isOperation(char ch) {
    final char c = ch;
    switch (c) {
    case '+':
    case '-':
    case '*':
    case '/':
        return true;
    default:
        return false;
    }
}

// 进行计算
BigInteger operate(BigInteger num1, BigInteger num2, char operation) {
    final BigInteger n1 = num1;
    final BigInteger n2 = num2;
    switch (operation) {
    case '+':
        return n1.add(n2);
    case '-':
        return n1.subtract(n2);
    case '*':
        return n1.multiply(n2);
    case '/':
        return n1.divide(n2);
    default:
        return null;
    }
}

}
`
第一次写博客，有写的不对的地方，希望大家多多指教。