在日常的 Java 开发工作中，我们经常需要处理各种类型的用户输入或配置数据。其中一项既有趣又具有挑战性的任务，就是计算以字符串形式给出的数学表达式。无论是开发一个简单的计算器应用，处理科学计算公式，还是在动态配置系统中执行逻辑判断，求值如 "3.5 + 2.8 * (4 - 1.2)" 这样的字符串，都是我们必须面对的实战场景。
在本文中，我们将深入探讨这一主题。你将学习到如何利用 Java 强大的生态系统，从最简单的内置 API 到复杂的自定义算法，来实现对数学表达式的求值。我们将不仅关注“怎么做”，还会深入分析“为什么这么做”，并分享在性能优化和错误处理方面的实用经验。
为什么这很有挑战性？
在深入代码之前，让我们先思考一下为什么计算字符串表达式并不是一件微不足道的小事。当我们在代码中直接写 int result = 10 - 4 * 5; 时，Java 编译器会帮我们处理所有繁琐的细节——它知道运算符优先级（乘法先于减法），知道如何解析数字，也知道如何处理内存。
但是，当我们面对一个字符串 "10-4*5" 时，对 Java 来说，它只是一串字符序列。我们需要自己编写逻辑来告诉程序：
- 词法分析：如何区分数字、运算符（+, -, *, /）和括号？
- 语法分析：如何处理运算符的优先级？比如，INLINECODE36efeacf 必须先于 INLINECODEe43f13df 进行计算。
- 执行逻辑：如何按照正确的顺序执行计算并得出结果？
常见场景示例
让我们通过几个具体的例子来明确我们的目标。以下是我们希望程序能够正确处理的输入和输出：
> 示例 1: 基础运算与优先级
> * 输入字符串: "10-4*5"
> * 期望输出: -10
> * 解析: 根据数学规则，先计算 INLINECODEc4f4bab3 得到 20，然后计算 INLINECODEc5176a56。
> 示例 2: 复杂嵌套与浮点数
> * 输入字符串: "3.5 + 2.8 * ( 4 - 1.2 ) / 2"
> * 期望输出: 7.42
> * 解析: 包含了括号改变优先级、浮点数运算以及多级运算符。
方法一：使用 ScriptEngine 接口（快速实现方案）
如果你正在寻找一种能在几分钟内解决问题的方案，且不介意引入 JavaScript 引擎作为依赖，那么 Java 内置的 javax.script 包是一个绝佳的选择。这就像是我们在 Java 代码中嵌入了一个微型的计算器。
#### 实现原理
Java 提供了一个脚本 API，允许我们与各种脚本引擎（如 JavaScript、Groovy 等）进行交互。由于 JavaScript 本身就非常擅长处理数学表达式，我们可以利用它的引擎来为我们的字符串求值。ScriptEngineManager 充当了一个管理者的角色，负责查找和创建合适的脚本引擎实例。
#### 代码示例
下面是一个完整的代码示例，展示了如何通过 Nashorn JavaScript 引擎（JDK 8 自带）来计算表达式。
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class StringCalculatorDemo {
public static void main(String[] args) {
// 1. 创建一个 ScriptEngineManager 来管理脚本引擎
ScriptEngineManager manager = new ScriptEngineManager();
// 2. 从管理器中获取一个 JavaScript 引擎实例
// 默认情况下，JDK 8 使用的是 Nashorn 引擎
ScriptEngine engine = manager.getEngineByName("JavaScript");
// 3. 定义我们想要计算的数学表达式字符串
String expression = "10-4*5";
try {
// 4. 调用 eval 方法执行表达式
// 这里的 eval 会将字符串当作 JavaScript 代码执行
Object result = engine.eval(expression);
System.out.println("计算结果: " + result);
// 我们也可以尝试更复杂的表达式
String complexExpression = "3.5 + 2.8 * ( 4 - 1.2 ) / 2";
Object complexResult = engine.eval(complexExpression);
System.out.println("复杂计算结果: " + complexResult);
} catch (ScriptException e) {
// 捕获脚本执行中的错误，比如表达式语法错误
System.err.println("表达式计算出错: " + e.getMessage());
}
}
}
#### 输出结果
运行上述代码，你将在控制台看到以下输出：
计算结果: -10.0
复杂计算结果: 7.42
#### 实用见解与注意事项
这种方法虽然简单快捷，但在实际生产环境中使用时，有几个关键的注意事项需要我们牢记：
- 版本兼容性警告：我们需要注意，Nashorn JavaScript 引擎及其相关的 API 在 Java 11 中已被标记为废弃，并在后续的 Java 版本（如 Java 15+）中被完全移除。如果你的项目正在使用 JDK 8，这完全没问题。但如果你正在升级到 JDK 17 或更高版本，这种方法将不再开箱即用，你可能需要引入第三方库（如 GraalVM 的 JavaScript 引擎）。
- 性能开销：每次调用
engine.eval都会启动一次脚本解析和执行的过程。对于高性能要求的场景（如每秒计算数万次），这可能会成为瓶颈。 - 安全性：由于我们是在执行脚本，如果表达式字符串来源于不可信的用户输入，可能会存在安全风险（虽然 Nashorn 在沙盒中运行，但仍需谨慎）。
方法二：使用栈数据结构（高性能算法方案）
为了解决依赖外部脚本引擎的问题，并为了更好地掌控计算逻辑，我们可以回到经典的计算机科学解决方案：使用栈。
#### 算法核心逻辑
我们将实现著名的 Dijkstra 双栈算法（也称为 Shunting-yard 算法的变体）来处理中缀表达式。这个算法的核心思想是将人类易于阅读的“中缀表达式”（如 1 + 2）转换为计算机易于计算的“后缀表达式”或直接求值。
我们需要使用两个栈：
- 数值栈：用于存储操作数（数字）。
- 运算符栈：用于存储运算符（+, -, *, /, (, )）。
执行流程如下：
- 扫描字符串：逐个字符读取表达式。
- 遇到数字：解析完整的数字（包括小数点），压入数值栈。
- 遇到左括号
(：压入运算符栈。 - 遇到右括号
)：开始处理，从运算符栈弹出符号并计算，直到遇到左括号。 - 遇到运算符：比较当前运算符与栈顶运算符的优先级。如果栈顶运算符优先级高（或者相等且具有左结合性），则先处理栈顶的运算符。这确保了乘法在加法之前执行。
#### 完整代码实现
以下是一个完整的、经过优化的实现，包含了详细的中文注释。
import java.util.Stack;
public class MathExpressionEvaluator {
/**
* 计算字符串形式数学表达式的主方法
* @param expression 数学表达式字符串
* @return 计算结果
*/
public static double evaluateExpression(String expression) {
// 将字符串转换为字符数组以便遍历
char[] tokens = expression.toCharArray();
// 创建两个栈：一个存储数值，一个存储运算符
Stack values = new Stack();
Stack operators = new Stack();
for (int i = 0; i < tokens.length; i++) {
// 1. 跳过空格字符
if (tokens[i] == ' ') {
continue;
}
// 2. 处理数字：如果是数字或小数点，开始解析
if (isDigit(tokens[i]) || tokens[i] == '.') {
StringBuilder sb = new StringBuilder();
// 继续读取直到不再是数字或小数点
// 注意：这里处理了多位数字和浮点数
while (i = 当前运算符优先级，
* 则先计算栈顶的运算符。
* 例如：遇到 "-" 而栈顶是 "*"，必须先算 "*"。
*/
while (!operators.isEmpty() && hasPrecedence(tokens[i], operators.peek())) {
values.push(applyOp(operators.pop(), values.pop(), values.pop()));
}
// 将当前运算符压入栈中
operators.push(tokens[i]);
}
}
// 6. 扫描结束后，处理栈中剩余的所有运算符
while (!operators.isEmpty()) {
values.push(applyOp(operators.pop(), values.pop(), values.pop()));
}
// 数值栈中剩下的最后一个元素就是最终结果
return values.pop();
}
/**
* 检查字符是否为运算符
*/
private static boolean isOperator(char c) {
return c == ‘+‘ || c == ‘-‘ || c == ‘*‘ || c == ‘/‘;
}
/**
* 检查字符是否为数字
*/
private static boolean isDigit(char c) {
return c >= ‘0‘ && c <= '9';
}
/**
* 判断运算符优先级
* 如果 op2 的优先级大于等于 op1，返回 true。
* 注意：op1 是当前读到的运算符，op2 是栈顶的运算符。
*/
public static boolean hasPrecedence(char op1, char op2) {
if (op2 == '(' || op2 == ')') {
return false;
}
if ((op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-')) {
return false;
}
return true;
}
/**
* 执行具体的数学运算
* @param op 运算符
* @param b 第二个操作数（因为栈是后进先出）
* @param a 第一个操作数
* @return 计算结果
*/
private static double applyOp(char op, double b, double a) {
switch (op) {
case '+':
return a + b;
case '-':
return a - b;
case '*':
return a * b;
case '/':
if (b == 0) {
throw new ArithmeticException("不能除以零");
}
return a / b;
}
return 0;
}
// 测试我们的求值器
public static void main(String[] args) {
String expr1 = "10 - 4 * 5";
String expr2 = "3.5 + 2.8 * ( 4 - 1.2 ) / 2";
String expr3 = "100 * ( 2 + 12 ) / 14";
System.out.println("表达式: " + expr1 + " = " + evaluateExpression(expr1));
System.out.println("表达式: " + expr2 + " = " + evaluateExpression(expr2));
System.out.println("表达式: " + expr3 + " = " + evaluateExpression(expr3));
}
}
#### 输出结果
运行上面的算法代码，你将得到精确的计算结果：
表达式: 10 - 4 * 5 = -10.0
表达式: 3.5 + 2.8 * ( 4 - 1.2 ) / 2 = 7.42
表达式: 100 * ( 2 + 12 ) / 14 = 100.0
深入理解与最佳实践
通过对比这两种方法，我们可以总结出一些关于 Java 编程和系统设计的深刻见解。
#### 1. 算法的重要性
使用栈的解决方案虽然代码量较大，但它展示了扎实的基础数据结构知识。它不依赖于任何外部引擎，运行速度极快，且内存占用完全可控。 对于高频交易系统、游戏引擎或嵌入式应用，这种纯算法实现是唯一的选择。
#### 2. 错误处理的最佳实践
在实际开发中，仅仅计算出结果是不够的，我们必须处理异常情况。在栈实现代码中，你可能注意到了 if (b == 0) 的检查。
- 除零错误：这是最容易忽略的错误。在字符串计算中，分母可能是动态计算的结果，因此运行时检查至关重要。
- 格式错误：如果用户输入了 INLINECODEc5ceebbb，我们的简单栈实现可能会崩溃。在生产代码中，你应该添加 INLINECODE2aff979d 块来捕获 INLINECODE0e5c411c 或 INLINECODEe0c3c8e0，并向用户返回友好的错误提示，例如：“表达式格式错误：符号位置不正确”。
#### 3. 性能优化建议
- 避免频繁的对象创建：在循环内部，我们应该尽量避免创建不必要的对象。例如，在解析数字时使用
StringBuilder而不是字符串拼接，是一个很好的性能优化习惯。 - 字符迭代优化：对于极长或性能敏感的表达式，直接操作字符数组（INLINECODE9fee9ac9）比使用 INLINECODEf398968c 效率更高，因为它避免了每次调用时的边界检查。
总结与展望
在这篇文章中，我们探索了在 Java 中计算字符串表达式的两种主要方式：利用 ScriptEngine 和使用 自定义栈算法。
- 如果你追求开发速度且环境允许（如使用 JDK 8），
ScriptEngine是一个强大的“黑盒”工具。 - 如果你追求性能、可控性和无依赖，掌握栈算法则是每一位专业开发者的必修课。
希望这篇文章不仅帮助你解决了手中的问题，还能让你在处理类似字符串解析任务时更加得心应手。不妨试着在你的下一个项目中实现一下这个求值器，或者尝试扩展它，加入对幂运算（^）或变量（如 x + y）的支持！