表达式计算器

实现一个简单的计算器，仅支持：+ - * / 四种运算，其中 * 和 / 运算优先级高于 + -，相同优先级的计算按先后顺序计算，限制如下：

1. 输入的符号数不超过10个

2. 每个数字的范围在0~100之间，包含0，不包含100

3. 不用考虑小数问题，即：4/3可以当作1来处理

示例如下：

示例一：
输入：3+5-2*3
输出：2
示例二：
输入：31*3/3-30
输出：1

 直接上代码：

package com.yaxin.show.config;

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;

public class calculator {

    // 操作数栈
    private static Stack<Double> Operands;
    // 操作符栈
    private static Stack<Character> Operators;
    // 操作符集合
    private static final Set<Character> C_OperatorSet = new HashSet<Character>() {
        /**
         *
         */
        private static final long serialVersionUID = 1L;

        {
            add('+');
            add('-');
            add('*');
            add('/');
            add('(');
            add(')');
        }
    };

    private static int getOperatorPriority(char ch) {
        if (ch == '+' || ch == '-')
            return 0;
        else if (ch == '*' || ch == '/')
            return 1;
        else
            return -1;
    }

    private static String infixToSuffix(String expression) {
        Operators = new Stack<>();
        Operators.clear();
        StringBuilder sBuilder = new StringBuilder();
        for (int i = 0; i < expression.length(); i++) {
            char ch = expression.charAt(i);
            if (ch == ' ')
                continue;
            if (C_OperatorSet.contains(ch)) {
                if (Operators.empty()) {
                    if (ch == ')') {
                        System.out.println("表达式不正确");
                        return sBuilder.toString();
                    }
                    Operators.push(ch);
                } else if (ch == '(') {
                    Operators.push(ch);
                } else if (ch == ')') {
                    char top;
                    while ((top = Operators.peek()) != '(') {
                        if (Operators.empty()) {
                            System.out.println("表达式不正确");
                            return sBuilder.toString();
                        }
                        sBuilder.append(top);
                        Operators.pop();
                    }
                    Operators.pop();
                } else {
                    char top = Operators.peek();
                    if (getOperatorPriority(ch) <= getOperatorPriority(top)) {
                        while (!Operators.empty()
                                && getOperatorPriority(ch) <= getOperatorPriority(top = Operators.peek())) {
                            sBuilder.append(top);
                            Operators.pop();
                        }
                    }
                    Operators.push(ch);
                }
            } else {
                sBuilder.append("[" + ch);
                while (i + 1 < expression.length()
                        && ((expression.charAt(i + 1) >= '0' && expression.charAt(i + 1) <= '9'))) {
                    ch = expression.charAt(i + 1);
                    sBuilder.append(ch);
                    ++i;
                }
                sBuilder.append(']');
            }
        }
        while (!Operators.empty()) {
            sBuilder.append(Operators.peek());
            Operators.pop();
        }
        return sBuilder.toString();
    }

    public static double evalExp(String expression) {
        Operands = new Stack<>();
        Operands.clear();
        double ret = 0;
        String suffix = infixToSuffix(expression);
        System.out.println("suffix: " + suffix);
        for (int i = 0; i < suffix.length(); i++) {
            if (suffix.charAt(i) == '[') {
                i++;
                int beginIndex = i, endIndex = i;
                while (']' != suffix.charAt(i)) {
                    i++;
                    endIndex++;
                }
                Operands.push(Double.valueOf(suffix.substring(beginIndex, endIndex)));
            } else {
                double left, right, res = 0;
                right = Operands.pop();
                left = Operands.pop();
                switch (suffix.charAt(i)) {
                    case '+':
                        res = left + right;
                        break;
                    case '-':
                        res = left - right;
                        break;
                    case '*':
                        res = left * right;
                        break;
                    case '/':
                        res = left / right;
                        break;
                }
                Operands.push(res);
            }
        }
        ret = Operands.pop();
        return ret;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个含+-*/的表达式，请确认输入合法");
        String expression = input.nextLine();
        System.out.println(expression + " =" + evalExp(expression));
        input.close();
    }


}