如何在Java函数中实现一个简单的计算器？
Java是一种面向对象的编程语言，它具有高效、可移植、可扩展、可靠性强等优点，常用于开发企业级应用程序和Web应用程序。在Java中，可以使用各种数据类型和操作符实现一个简单的计算器，主要包括四则运算（加、减、乘、除）和取模运算。
首先，需要定义一个Java函数来接收用户输入的表达式，并返回计算结果。可以使用Scanner类从控制台读取用户输入的内容，如下所示：
import java.util.Scanner;
public class Calculator {
public static void main(String[]args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入算术表达式：");
String expression = scan.nextLine();
int result = calculate(expression);
System.out.println("计算结果为：" + result);
}
}
上述代码中，Scanner类用于从控制台读取用户输入的表达式，接着调用calculate函数计算表达式的结果，最后输出计算结果。接下来，需要实现calculate函数来完成计算器的具体功能。
一般情况下，表达式的计算可以通过栈来完成。在计算器中，需要维护两个栈：一个操作符栈和一个操作数栈。具体过程如下：
1. 初始化两个栈，一个为操作符栈，一个为操作数栈。
2. 从左至右扫描表达式，对于每个元素，判断其类型：
- 如果是数字，压入操作数栈。
- 如果是操作符：
a. 如果操作符栈为空，或栈顶操作符为“（”，则直接入栈。
b. 如果当前操作符优先级大于栈顶操作符优先级，则直接入栈。
c. 否则，从操作符栈中弹出一个操作符和两个操作数进行运算，将结果压入操作数栈，并继续判断。
3. 如果扫描完表达式后，操作符栈中仍有元素，则取出一个操作符和两个操作数进行运算，将结果压入操作数栈，直到操作符栈为空。
4. 最终，操作数栈中只剩下一个元素，即计算结果。
可以定义一个Symbol类表示操作符，包括操作符的类型（加减乘除或左右括号）和优先级。可以使用switch语句来判断操作符的类型，并根据优先级进行比较和计算。具体实现如下：
import java.util.Stack;
public class Calculator {
static class Symbol {
public static final int LEFT_BRACKETS = 0; // 左括号
public static final int RIGHT_BRACKETS = 1; // 右括号
public static final int OPERATOR_ADD = 2; // 加法操作符
public static final int OPERATOR_SUB = 3; // 减法操作符
public static final int OPERATOR_MUL = 4; // 乘法操作符
public static final int OPERATOR_DIV = 5; // 除法操作符
private int type; // 操作符类型
private int priority; // 操作符优先级
public Symbol(int type, int priority) {
this.type = type;
this.priority = priority;
}
public int getType() {
return type;
}
public int getPriority() {
return priority;
}
public int calculate(int num1, int num2) {
switch (type) {
case OPERATOR_ADD:
return num1 + num2;
case OPERATOR_SUB:
return num1 - num2;
case OPERATOR_MUL:
return num1 * num2;
case OPERATOR_DIV:
return num1 / num2;
default:
throw new UnsupportedOperationException("Unsupported Symbol");
}
}
}
public static int calculate(String expression) {
Stack<Integer> numStack = new Stack<>(); // 操作数栈
Stack<Symbol> symbolStack = new Stack<>(); // 操作符栈
int i = 0;
while (i < expression.length()) {
char c = expression.charAt(i);
if (Character.isDigit(c)) { // 如果是数字
int start = i;
while (i < expression.length() && Character.isDigit(expression.charAt(i))) {
i++;
}
int num = Integer.parseInt(expression.substring(start, i)); // 转换为整数
numStack.push(num);
} else { // 如果是操作符
Symbol symbol = new Symbol(-1, -1);
switch (c) {
case '(':
symbol = new Symbol(Symbol.LEFT_BRACKETS, -1);
symbolStack.push(symbol);
break;
case ')':
while (symbolStack.peek().getType() != Symbol.LEFT_BRACKETS) {
int num2 = numStack.pop();
int num1 = numStack.pop();
int result = symbolStack.pop().calculate(num1, num2);
numStack.push(result);
}
symbolStack.pop(); // 弹出左括号
break;
case '+':
symbol = new Symbol(Symbol.OPERATOR_ADD, 1);
processSymbol(symbol, numStack, symbolStack);
break;
case '-':
symbol = new Symbol(Symbol.OPERATOR_SUB, 1);
processSymbol(symbol, numStack, symbolStack);
break;
case '*':
symbol = new Symbol(Symbol.OPERATOR_MUL, 2);
processSymbol(symbol, numStack, symbolStack);
break;
case '/':
symbol = new Symbol(Symbol.OPERATOR_DIV, 2);
processSymbol(symbol, numStack, symbolStack);
break;
default:
throw new UnsupportedOperationException("Unsupported Character");
}
i++;
}
}
while (!symbolStack.isEmpty()) { // 扫描完表达式后，操作符栈中仍有元素
int num2 = numStack.pop();
int num1 = numStack.pop();
int result = symbolStack.pop().calculate(num1, num2);
numStack.push(result);
}
return numStack.pop(); // 返回计算结果
}
private static void processSymbol(Symbol symbol, Stack<Integer> numStack, Stack<Symbol> symbolStack) {
while (!symbolStack.isEmpty() && symbol.getPriority() <= symbolStack.peek().getPriority()) {
int num2 = numStack.pop();
int num1 = numStack.pop();
int result = symbolStack.pop().calculate(num1, num2);
numStack.push(result);
}
symbolStack.push(symbol);
}
public static void main(String[]args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入算术表达式：");
String expression = scan.nextLine();
int result = calculate(expression);
System.out.println("计算结果为：" + result);
}
}
上述代码中，首先定义了一个Symbol类来表示操作符，包括操作符的类型和优先级。接着定义了一个calculate函数，该函数用于计算表达式的结果。在calculate函数中，定义了一个操作数栈和一个操作符栈。使用while循环遍历表达式的每一个字符，对每个字符进行判断，并执行相应的处理。
如果当前字符是数字，则使用while循环获取所有的数字并转换为整数，然后压入操作数栈。
如果当前字符是操作符，则根据其类型创建一个Symbol对象，并使用processSymbol函数处理操作符栈和操作数栈。processSymbol函数用于将操作符依照优先级压入操作符栈或从操作符栈中取出操作符进行运算，并将结果压入操作栈。
如果扫描完表达式后，操作符栈中仍然有元素，则依次取出一个操作数和两个操作符进行运算，将结果压入操作数栈中，直到操作符栈为空。最终，操作数栈中只有一个元素，即为表达式的计算结果，将该元素返回即可。
总结：
通过上述代码的实现，Java函数已经实现了一个简单的计算器。该计算器支持加、减、乘、除以及括号，并可以计算带有多位数的表达式。实际应用中