要实现一个计算器，Java 算法需要处理基本的算术运算、操作符优先级和括号嵌套。 主要步骤包括：读取和解析输入、将中缀表达式转换为后缀表达式（或逆波兰表达式）、使用栈进行计算。以下是对如何实现这些步骤的详细描述。
一、读取和解析输入
实现计算器的第一步是读取并解析用户输入的数学表达式。可以使用以下方法来读取和解析输入：
- 使用正则表达式进行分割： 利用正则表达式将输入字符串拆分成操作数和操作符。
- 遍历字符串： 手动遍历字符串以识别数字和操作符，并将它们存储在相应的数据结构中。
二、中缀表达式转换为后缀表达式
为了简化计算过程，我们需要将中缀表达式转换为后缀表达式。可以使用Shunting Yard算法来实现这一转换。该算法由艾兹赫尔·戴克斯特拉提出，主要用于处理运算符优先级和括号。
三、使用栈进行计算
在得到后缀表达式后，我们可以使用栈来进行计算。每当遇到一个操作数时，将其压入栈中；每当遇到一个操作符时，从栈中弹出适当数量的操作数进行计算，并将结果重新压入栈中。
详细实现
以下是详细的实现步骤和代码示例：
一、读取和解析输入
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Calculator {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter a mathematical expression: ");
String input = scanner.nextLine();
List<String> tokens = tokenize(input);
System.out.println("Tokens: " + tokens);
}
private static List<String> tokenize(String input) {
List<String> tokens = new ArrayList<>();
StringBuilder token = new StringBuilder();
for (char ch : input.toCharArray()) {
if (Character.isDigit(ch) || ch == '.') {
token.append(ch);
} else {
if (token.length() > 0) {
tokens.add(token.toString());
token.setLength(0);
}
if (!Character.isWhitespace(ch)) {
tokens.add(String.valueOf(ch));
}
}
}
if (token.length() > 0) {
tokens.add(token.toString());
}
return tokens;
}
}
二、中缀表达式转换为后缀表达式
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class Calculator {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter a mathematical expression: ");
String input = scanner.nextLine();
List<String> tokens = tokenize(input);
List<String> postfix = infixToPostfix(tokens);
System.out.println("Postfix: " + postfix);
}
private static List<String> tokenize(String input) {
List<String> tokens = new ArrayList<>();
StringBuilder token = new StringBuilder();
for (char ch : input.toCharArray()) {
if (Character.isDigit(ch) || ch == '.') {
token.append(ch);
} else {
if (token.length() > 0) {
tokens.add(token.toString());
token.setLength(0);
}
if (!Character.isWhitespace(ch)) {
tokens.add(String.valueOf(ch));
}
}
}
if (token.length() > 0) {
tokens.add(token.toString());
}
return tokens;
}
private static List<String> infixToPostfix(List<String> infixTokens) {
List<String> postfix = new ArrayList<>();
Stack<String> stack = new Stack<>();
for (String token : infixTokens) {
if (isNumber(token)) {
postfix.add(token);
} else if (token.equals("(")) {
stack.push(token);
} else if (token.equals(")")) {
while (!stack.isEmpty() && !stack.peek().equals("(")) {
postfix.add(stack.pop());
}
stack.pop();
} else {
while (!stack.isEmpty() && precedence(stack.peek()) >= precedence(token)) {
postfix.add(stack.pop());
}
stack.push(token);
}
}
while (!stack.isEmpty()) {
postfix.add(stack.pop());
}
return postfix;
}
private static boolean isNumber(String token) {
try {
Double.parseDouble(token);
return true;
} catch (NumberFormatException e) {
return false;
}
}
private static int precedence(String op) {
switch (op) {
case "+":
case "-":
return 1;
case "*":
case "/":
return 2;
default:
return -1;
}
}
}
三、使用栈进行计算
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;
public class Calculator {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter a mathematical expression: ");
String input = scanner.nextLine();
List<String> tokens = tokenize(input);
List<String> postfix = infixToPostfix(tokens);
double result = evaluatePostfix(postfix);
System.out.println("Result: " + result);
}
private static List<String> tokenize(String input) {
List<String> tokens = new ArrayList<>();
StringBuilder token = new StringBuilder();
for (char ch : input.toCharArray()) {
if (Character.isDigit(ch) || ch == '.') {
token.append(ch);
} else {
if (token.length() > 0) {
tokens.add(token.toString());
token.setLength(0);
}
if (!Character.isWhitespace(ch)) {
tokens.add(String.valueOf(ch));
}
}
}
if (token.length() > 0) {
tokens.add(token.toString());
}
return tokens;
}
private static List<String> infixToPostfix(List<String> infixTokens) {
List<String> postfix = new ArrayList<>();
Stack<String> stack = new Stack<>();
for (String token : infixTokens) {
if (isNumber(token)) {
postfix.add(token);
} else if (token.equals("(")) {
stack.push(token);
} else if (token.equals(")")) {
while (!stack.isEmpty() && !stack.peek().equals("(")) {
postfix.add(stack.pop());
}
stack.pop();
} else {
while (!stack.isEmpty() && precedence(stack.peek()) >= precedence(token)) {
postfix.add(stack.pop());
}
stack.push(token);
}
}
while (!stack.isEmpty()) {
postfix.add(stack.pop());
}
return postfix;
}
private static boolean isNumber(String token) {
try {
Double.parseDouble(token);
return true;
} catch (NumberFormatException e) {
return false;
}
}
private static int precedence(String op) {
switch (op) {
case "+":
case "-":
return 1;
case "*":
case "/":
return 2;
default:
return -1;
}
}
private static double evaluatePostfix(List<String> postfixTokens) {
Stack<Double> stack = new Stack<>();
for (String token : postfixTokens) {
if (isNumber(token)) {
stack.push(Double.parseDouble(token));
} else {
double b = stack.pop();
double a = stack.pop();
switch (token) {
case "+":
stack.push(a + b);
break;
case "-":
stack.push(a - b);
break;
case "*":
stack.push(a * b);
break;
case "/":
stack.push(a / b);
break;
}
}
}
return stack.pop();
}
}
代码分析
1、读取和解析输入
首先，我们使用 Scanner 读取用户输入。然后，通过遍历字符串，将数字和操作符分离出来。数字包括整数和小数，而操作符包括 +、-、*、/ 以及括号。
2、中缀表达式转换为后缀表达式
使用 Shunting Yard 算法处理操作符优先级和括号。该算法通过栈来实现，将中缀表达式转换为后缀表达式。这一步使得后续的计算变得更加简单和高效。
3、使用栈进行计算
在得到后缀表达式后，利用栈来进行计算。当遇到操作数时，将其压入栈中；当遇到操作符时，从栈中弹出适当数量的操作数进行计算，并将结果重新压入栈中。最终，栈中剩下的唯一一个元素即为计算结果。
扩展功能
上述代码实现了基本的四则运算。如果需要支持更多功能，例如指数运算、求余运算等，可以在解析输入和计算过程中添加相应的处理逻辑。
结论
通过上述方法，我们可以用Java实现一个功能完整的计算器。这个计算器能够处理基本的算术运算、操作符优先级和括号嵌套，并且具有较高的扩展性，可以根据需求添加更多功能。
相关问答FAQs：
1. 如何使用Java算法实现一个简单的计算器？
您可以使用Java算法实现一个简单的计算器，以下是一个示例：
import java.util.Scanner;
public class Calculator {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入第一个数字：");
double num1 = scanner.nextDouble();
System.out.print("请输入运算符（+、-、*、/）：");
char operator = scanner.next().charAt(0);
System.out.print("请输入第二个数字：");
double num2 = scanner.nextDouble();
double result = 0;
switch(operator) {
case '+':
result = num1 + num2;
break;
case '-':
result = num1 - num2;
break;
case '*':
result = num1 * num2;
break;
case '/':
result = num1 / num2;
break;
default:
System.out.println("无效的运算符！");
}
System.out.println("运算结果：" + result);
scanner.close();
}
}
2. 如何在Java中处理计算器中的错误输入？
为了处理计算器中的错误输入，您可以添加一些错误检查和异常处理的代码。例如，可以使用try-catch语句来捕获用户输入非数字的情况，并给出错误提示。
try {
double num1 = scanner.nextDouble();
// ...
} catch (InputMismatchException e) {
System.out.println("请输入有效的数字！");
}
3. 如何在Java中实现复杂的计算器功能，例如支持括号和多个运算符优先级？
要实现复杂的计算器功能，您可以使用逆波兰表达式（Reverse Polish Notation，RPN）或栈来处理运算符的优先级和括号的顺序。首先，将中缀表达式转换为后缀表达式，然后使用栈来计算后缀表达式的结果。
您可以使用Java中的Stack类来实现栈的功能，并编写相应的算法来处理运算符的优先级和括号的顺序。以下是一个示例：
import java.util.Stack;
public class Calculator {
public static void main(String[] args) {
String expression = "(2+3)*4-5";
String postfixExpression = convertToPostfix(expression);
double result = calculatePostfix(postfixExpression);
System.out.println("运算结果：" + result);
}
private static String convertToPostfix(String expression) {
// TODO: 中缀表达式转后缀表达式的算法
return "";
}
private static double calculatePostfix(String postfixExpression) {
// TODO: 计算后缀表达式的算法
return 0;
}
}
请注意，上述示例中的convertToPostfix和calculatePostfix方法还未实现，您需要根据具体的需求编写相应的代码来完成这些功能。
文章包含AI辅助创作，作者：Edit2，如若转载，请注明出处：https://docs.pingcode.com/baike/242534
