表达式求值

import java.util.*;
import javax.script.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws Exception {
        Scanner scan = new  Scanner(System.in);
        String input = scan.nextLine();
        ScriptEngine scriptEngine = new ScriptEngineManager().getEngineByName("nashorn");
        System.out.println(scriptEngine.eval(input));
    }
}

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.Stack;
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();
        System.out.println(calculate(line));
    }
    public static int calculate(String line){
        Stack<Integer> stack = new Stack<>();
        char sign = '+';
        int number = 0;
        int len = line.length();
        char[] chars = line.toCharArray();
        for(int i = 0; i < len; i++){
            char ch = chars[i];
            if(ch == ' ')continue;
            if(Character.isDigit(ch)){
                number = number * 10 + ch - '0';
            }
            if(ch == '('){
                int count = 1;
                int j = i + 1;
                while(count > 0){
                    if(chars[j] == ')')count--;
                    if(chars[j] == '(')count++;
                    j++;
                }
                //递归，解小括号中的表达式
                number = calculate(line.substring(i + 1, j - 1));
                i = j - 1;
            }
            if(!Character.isDigit(ch) || i == len - 1){
                if(sign == '+'){
                    stack.push(number);
                }else if(sign == '-'){
                    stack.push(-1 *number);
                }else if(sign =='*'){
                    stack.push(stack.pop() * number);
                }else if(sign == '/'){
                    stack.push(stack.pop() / number);
                }
                //更新符号
                sign = ch;
                //刷新数字
                number = 0;
            }
        }
        //栈中数字求和得到结果
        int ans = 0;
        while (!stack.isEmpty()) {
            ans += stack.pop();
        }
        return ans;
    }
}

import java.util.HashMap;
import java.util.Scanner;
import java.util.Stack;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char[] charArray = (sc.next() + "#").toCharArray();
        Stack<Character> signStack = new Stack<>();
        Stack<Integer> numStack = new Stack<>();
        HashMap<Character, Integer> map = new HashMap<>();
        map.put('+', 0);
        map.put('-', 1);
        map.put('*', 2);
        map.put('/', 3);
        map.put('(', 4);
        map.put(')', 5);
        map.put('#', 6);
        char[][] chars = new char[][]{
                {'>', '>', '<', '<', '<', '>', '>'},
                {'>', '>', '<', '<', '<', '>', '>'},
                {'>', '>', '>', '>', '<', '>', '>'},
                {'>', '>', '>', '>', '<', '>', '>'},
                {'<', '<', '<', '<', '<', '=', 'e'},
                {'e', 'e', 'e', 'e', 'e', 'e', 'e'},
                {'<', '<', '<', '<', '<', 'e', '='},
        };
        signStack.push('#');
        int i = 0;
        while (i < charArray.length) {
            int sign = 1;
            if ((i == 0 || charArray[i - 1] == '(') && charArray[i] == '-') {
                i++;
                sign = -1;
            }
            if (isNum(charArray[i])) {
                int sum = 0;
                while (isNum(charArray[i])) {
                    sum *= 10;
                    sum += charArray[i] - '0';
                    i++;
                }
                numStack.push(sign * sum);
            } else {
                switch (chars[map.get(signStack.peek())][map.get(charArray[i])]) {
                    case '<':
                        signStack.push(charArray[i++]);
                        break;
                    case '>':
                        Integer rightVal = numStack.pop();
                        Integer leftVal = numStack.pop();
                        Character ops = signStack.pop();
                        numStack.push(operate(leftVal, rightVal, ops));
                        break;
                    case '=':
                        signStack.pop();
                        i++;
                        break;
                    default:
                        throw new RuntimeException("error");
                }
            }
        }
        if (signStack.isEmpty() && numStack.size() == 1) System.out.println(numStack.peek());
    }

    private static Integer operate(Integer leftVal, Integer rightVal, Character ops) {
        switch (ops) {
            case '+':
                return leftVal + rightVal;
            case '-':
                return leftVal - rightVal;
            case '*':
                return leftVal * rightVal;
            case '/':
                return leftVal / rightVal;
            default:
                return null;
        }
    }

    private static boolean isNum(char c) {
        return c >= '0' && c <= '9';
    }
}

// 提交一个笨方法
public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    String str = in.nextLine();
    while (str.contains(")")) {
        int start = 0;
        // 发现反括号往前搜索最近的一个括号，先解析本组数据
        int end = str.indexOf(")");
        for (int i = end; i >= 0; i--) {
            if ('(' == str.charAt(i)) {
                start = i;
                break;
            }
        }
        String tmp = str.substring(start, end + 1);
        // System.out.println("获取括号 tmp=" + tmp);
        int n = getResult(str.substring(start + 1, end));
        str = str.replace(tmp, String.valueOf(n));
    }
    System.out.println(getResult(str) + "");
}

private static int getResult(String str) {
    // 运算乘法
    while (str.contains("*")) {
        int pre = getPreNum(str, "*", "\\d+");
        int next = getNextNum(str, "*");
        str = str.replace(pre+"*"+next, String.valueOf(pre*next));
        // System.out.println("运算* str=" + str);
    }
    // 运算除法
    while (str.contains("/")) {
        int pre = getPreNum(str, "*/", "\\d+");
        int next = getNextNum(str, "/");
        str = str.replace(pre+"/"+next, String.valueOf(pre/next));
        // System.out.println("运算/ str=" + str);
    }

    str = str.replace("+-", "-");
    str = str.replace("--", "+");
    if (str.startsWith("+")) {
        str = str.substring(1);
    }
    // 运算加法
    while (str.contains("+")) {
        str = str.replaceAll("\\+0|\\-0", "");
        int pre = getPreNum(str, "+", "\\-*\\d+"); // 加减法运算符前面的数把符号也算上
        int next = getNextNum(str, "+");
        // System.out.println("运算+ pre=" + pre + ",next=" + next);
        str = str.replace(pre+"+"+next, pre < 0? "+" + String.valueOf(pre+next) : String.valueOf(pre+next));
    }

    str = str.replace("+-", "-");
    str = str.replace("--", "+");
    if (str.startsWith("+")) {
        str = str.substring(1);
    }
    // 运算减法
    while (str.substring(1).contains("-")) {
        str = str.replaceAll("\\+0|\\-0", "");
        if (str.startsWith("-")) {
            str = str.substring(1);
            int pre = getPreNum(str, "-", "\\-*\\d+"); // 加减法运算符前面的数把符号也算上
            int next = getNextNum(str, "-");
            str = "-" + str.replace(pre+"-"+next, String.valueOf(pre+next));
        } else {
            int pre = getPreNum(str, "-", "\\-*\\d+"); // 加减法运算符前面的数把符号也算上
            int next = getNextNum(str, "-");
            str = str.replace(pre+"-"+next, String.valueOf(pre-next));
        }
        // System.out.println("运算- str=" + str);
    }
    return str.startsWith("-") ? -Integer.parseInt(str.substring(1)) : Integer.parseInt(str);
}

// 获取运算符前面的数
private static int getPreNum(String str, String fuhao, String relgex) {
    int n = str.indexOf(fuhao);
    String result = "";
    String tmp = result;
    while (true && n > 0) {
        tmp = String.valueOf(str.charAt((n - 1))) + tmp;
        if (!tmp.matches(relgex)) {
            break;
        }
        result = tmp;
        // System.out.println("前面数=" + tmp);
        --n;
    }
    return result == ""? 0: (result.contains("-")? -Integer.parseInt(result.substring(1)): Integer.parseInt(result));
}

// 获取运算符后面的数
private static int getNextNum(String str, String fuhao) {
    int n = str.indexOf(fuhao);
    String result = "";
    String tmp = result;
    while (true && n < str.length() - 1) {
        tmp = tmp + String.valueOf(str.charAt((n + 1)));
        if (!tmp.matches("\\-|\\-*\\d+")) {
            break;
        }
        result = tmp;
        // System.out.println("后面数=" + tmp);
        ++n;
    }
    return result == "" ? 0: (result.startsWith("-") ? -Integer.parseInt(result.substring(1)): Integer.parseInt(result));
}