在Java计算器中实现括号功能的核心在于：使用栈来处理括号的优先级、递归解析表达式、将中缀表达式转换为后缀表达式，并用后缀表达式来进行计算。 栈结构提供了一个理想的方式来处理括号和操作符的优先级问题。本文将详细介绍如何通过以下步骤实现一个支持括号的Java计算器。
一、基础概念
在实现计算器之前，我们需要了解一些基础概念，这些概念将帮助我们更好地理解和实现代码。
1、栈的基础
栈是一种后进先出（LIFO，Last In First Out）的数据结构，常用于处理递归、回溯等问题。在计算器中，栈用于存储操作数和操作符，特别是在处理括号时非常有效。
2、中缀表达式与后缀表达式
中缀表达式是我们日常使用的表达式，如 (1 + 2) * 3。后缀表达式则是将操作符放在操作数后面，如 1 2 + 3 *。后缀表达式的优点是计算时不需要考虑操作符的优先级和括号问题。
3、转换算法
将中缀表达式转换为后缀表达式的常用算法是“逆波兰表达式”（Reverse Polish Notation, RPN），这种方法利用栈来处理操作符的优先级和括号。
二、实现思路
1、解析表达式
首先，我们需要解析输入的中缀表达式，并将其转换为后缀表达式。解析表达式时，我们需要处理数字、操作符和括号。
2、处理括号
在解析过程中，遇到左括号时，将其压入栈中；遇到右括号时，不断弹出栈顶的操作符，直到遇到左括号。这样可以确保括号内的表达式先被计算。
3、计算后缀表达式
转换为后缀表达式后，我们需要计算该表达式的值。通过遍历后缀表达式，遇到数字时将其压入栈中，遇到操作符时弹出栈顶的两个数字进行计算，并将结果压回栈中。
三、代码实现
1、工具类
首先，我们需要一个工具类来处理操作符的优先级和计算操作。
import java.util.Stack;
public class Calculator {
// 优先级定义
private static final int ADD = 1;
private static final int SUBTRACT = 1;
private static final int MULTIPLY = 2;
private static final int DIVIDE = 2;
// 判断字符是否是操作符
private boolean isOperator(char c) {
return c == '+' || c == '-' || c == '*' || c == '/';
}
// 获取操作符的优先级
private int getPriority(char operator) {
switch (operator) {
case '+':
return ADD;
case '-':
return SUBTRACT;
case '*':
return MULTIPLY;
case '/':
return DIVIDE;
default:
return 0;
}
}
// 计算两个数的操作
private int calculate(int num1, int num2, char operator) {
switch (operator) {
case '+':
return num1 + num2;
case '-':
return num1 - num2;
case '*':
return num1 * num2;
case '/':
if (num2 == 0) throw new ArithmeticException("Divide by zero");
return num1 / num2;
default:
return 0;
}
}
}
2、转换中缀表达式为后缀表达式
接下来，我们需要一个方法将中缀表达式转换为后缀表达式。
import java.util.ArrayList;
import java.util.List;
public class Calculator {
// 其他方法...
// 中缀表达式转换为后缀表达式
public List<String> infixToPostfix(String expression) {
Stack<Character> stack = new Stack<>();
List<String> postfix = new ArrayList<>();
for (int i = 0; i < expression.length(); i++) {
char c = expression.charAt(i);
if (Character.isDigit(c)) {
StringBuilder number = new StringBuilder();
while (i < expression.length() && Character.isDigit(expression.charAt(i))) {
number.append(expression.charAt(i++));
}
postfix.add(number.toString());
i--;
} else if (c == '(') {
stack.push(c);
} else if (c == ')') {
while (!stack.isEmpty() && stack.peek() != '(') {
postfix.add(String.valueOf(stack.pop()));
}
stack.pop(); // 弹出 '('
} else if (isOperator(c)) {
while (!stack.isEmpty() && getPriority(stack.peek()) >= getPriority(c)) {
postfix.add(String.valueOf(stack.pop()));
}
stack.push(c);
}
}
while (!stack.isEmpty()) {
postfix.add(String.valueOf(stack.pop()));
}
return postfix;
}
}
3、计算后缀表达式
转换为后缀表达式后，我们需要一个方法来计算其值。
import java.util.List;
public class Calculator {
// 其他方法...
// 计算后缀表达式的值
public int evaluatePostfix(List<String> postfix) {
Stack<Integer> stack = new Stack<>();
for (String token : postfix) {
if (token.matches("\d+")) {
stack.push(Integer.parseInt(token));
} else if (isOperator(token.charAt(0))) {
int num2 = stack.pop();
int num1 = stack.pop();
int result = calculate(num1, num2, token.charAt(0));
stack.push(result);
}
}
return stack.pop();
}
}
4、主方法
最后，我们需要一个主方法来整合上述所有方法，完成表达式的解析和计算。
public class Calculator {
// 其他方法...
// 主方法
public int calculateExpression(String expression) {
List<String> postfix = infixToPostfix(expression);
return evaluatePostfix(postfix);
}
public static void main(String[] args) {
Calculator calculator = new Calculator();
String expression = "(1+2)*(3-4)+5";
int result = calculator.calculateExpression(expression);
System.out.println("Result: " + result);
}
}
四、优化与扩展
1、支持小数
上面的代码仅支持整数运算，我们可以扩展支持小数。例如，将Character.isDigit(c)替换为 Character.isDigit(c) || c == '.'，并在数字解析时处理小数点。
2、支持更多操作符
我们可以扩展支持更多操作符，如幂运算（^）、模运算（%）等。只需在isOperator、getPriority和calculate方法中添加相应的逻辑。
3、错误处理
当前代码中没有详细的错误处理机制，如不匹配的括号、非法字符等。可以添加更多的异常处理来提高代码的健壮性。
五、总结
通过本文的介绍，我们了解了如何使用Java实现一个支持括号的计算器。核心在于使用栈来处理操作符的优先级和括号，通过将中缀表达式转换为后缀表达式，并计算后缀表达式的值。希望本文能帮助你更好地理解和实现Java计算器。
相关问答FAQs：
1. 为什么我在Java计算器中使用括号时会遇到问题？
在Java计算器中，使用括号可能会导致问题，因为计算器需要正确地解析和计算表达式中的括号。如果括号没有正确匹配，或者括号的顺序不正确，计算结果可能会出现错误。
2. 如何在Java计算器中正确地使用括号？
要在Java计算器中正确使用括号，您需要遵循一些规则。首先，确保括号成对出现，即每个左括号都有一个相应的右括号。其次，确保括号的顺序正确，即内部的括号先计算。最后，您可以使用递归的方式来处理嵌套的括号，以确保正确地解析和计算表达式。
3. 如何在Java计算器中实现括号的优先级？
要在Java计算器中实现括号的优先级，可以使用栈的数据结构来处理括号。当遇到左括号时，将其压入栈中，并在遇到右括号时从栈中弹出。这样可以确保括号的优先级得到正确的处理。同时，在计算表达式时，可以优先计算括号内的表达式，以确保括号的优先级被正确应用。
原创文章，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/226429
