题目描述：

请实现如下接口

    /* 功能：四则运算

     * 输入：strExpression：字符串格式的算术表达式，如: "3+2*{1+2*[-4/(8-6)+7]}"

         * 返回：算术表达式的计算结果

     */

    public static int calculate(String strExpression)

    {

        /* 请实现*/

        return 0;

    } 

约束：

1. pucExpression字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。

2. pucExpression算术表达式的有效性由调用者保证; 

Java实现：

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String str = sc.nextLine();
            Stack<Character> symbolStack = new Stack<Character>();
            String suffix = infixToSuffix(str, symbolStack);// 中缀表达式变为后缀表达式。
            System.out.println(calculateSuffix(suffix));// 计算后缀表达式的结果
        }
    }
  

    public static String infixToSuffix(String infix, Stack<Character> stack) {
        StringBuffer suffix = new StringBuffer();
        char[] ch = infix.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            if (ch[i] == '(' || ch[i] == '[' || ch[i] == '{') {
                stack.push('(');
            } else if (ch[i] >= '0' && ch[i] <= '9')
                suffix.append(ch[i]);
            else if (ch[i] == '+' || ch[i] == '-')
            {
                if (ch[i] == '-')
                {
                    char before = ch[i - 1];
                    if (before == '(' || before == '[' || before == '{' || before == '+' || before == '-' || before == '*' || before == '/')
                        suffix.append(" ").append(ch[i]);
                    else {
                        while (!stack.isEmpty()) {
                            if (stack.peek() != '(')
                                suffix.append(" ").append(stack.pop());
                            else
                                break;
                        }
                        stack.push(ch[i]);
                        suffix.append(" ");
                    }
                } else {
                    while (!stack.isEmpty()) {
                        if (stack.peek() != '(') {
                            suffix.append(" ").append(stack.pop());
                        } else
                            break;
                    }
                    stack.push(ch[i]);
                    suffix.append(" ");
  
                }
            } else if (ch[i] == '*' || ch[i] == '/') {
                while (!stack.isEmpty()) {
                    char tmp = stack.peek();
                    if (tmp == '*' || tmp == '/') {
                        suffix.append(" ").append(stack.pop()).append(" ");
                    } else {
                        break;
                    }
                }
                stack.push(ch[i]);
                suffix.append(" ");
            } else {
                while (!stack.isEmpty()) {
                    char tmp = stack.pop();
                    if (tmp != '(') {
                        suffix.append(" ").append(tmp);
  
                    } else
                        break;
                }
            }
        }
        while (!stack.isEmpty()) {
            suffix.append(" ").append(stack.pop());
        }
        return suffix.toString();
    }
  
    public static int calculateSuffix(String suffix) {
        Stack<Integer> numStack = new Stack<Integer>();
        String[] str = suffix.split("\\s+");
        int n1, n2;
        for (int i = 0; i < str.length; i++) {
            String s = str[i];
            if (s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/"))// 读到运算符则从栈中依次弹出两个数分别到n2和n1,然后以“X运算符Y”的形式计算机出结果，再压加栈S中；
            {
                n2 = numStack.pop();
                n1 = numStack.pop();
                if (s.equals("+"))
                    numStack.push(n1 + n2);
                else if (s.equals("-"))
                    numStack.push(n1 - n2);
                else if (s.equals("*"))
                    numStack.push(n1 * n2);
                else if (s.equals("/"))
                    numStack.push(n1 / n2);
            } else
                numStack.push(Integer.valueOf(s));// 遇到数字，便将它转换为数值压入栈中
        }
        return numStack.pop();// 将最终的结果弹出栈
    }
}

关键点：

中缀表达式与后缀表达式

举个例子：计算9+(3-1)*3+6/2,转换为后缀表达式即为9 3 1 - 3 * + 6 2 / +(怎么转换后面再讲)。计算规则就是建立一个空栈，遇到数字就入栈，遇到符号就以符号前面的两个数为运算数进行计算（不好理解？请看图）