此篇是一个java入门级的实验展示。
利用递归下降法能够实现计算器的运算优先级。
看了很多自制的计算器，并没有运用递归下降法，它们 都只是两个数运算获得一个结果，然后利用这一结果继续与一个数相运算。我认为这样不能够展示完全的运算式，所以写了这一个递归下降法计算器。
(资料图片)
实现结果样例
以下是实现代码:
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.Expression;
import java.util.ArrayList;
import java.util.Stack;
public class Calculator extends JFrame implements ActionListener {
// 第一行的计算式
private ArrayList<String> tokens;private int pos = 0;//pos用于确定token位置
private JTextField expText = new JTextField();
// 第二行的计算结果，初始值设为0
private JTextField resultText = new JTextField("0");
// 构造方法
public Calculator() {
// 调用父类的构造函数，
super("计算器");
// 各个按钮上的文字
String[] keysValue = { "7", "8", "9", "÷", "4", "5", "6",
"×", "1", "2", "3", "-", "0","CE", "+","=","(",")" };
// 各个按钮上的动作命令标识
String[] actionCmd = { "7", "8", "9", "/", "4", "5", "6",
"*", "1", "2", "3", "-", "0","CE", "+","=","(",")" };
JButton keys[] = new JButton[keysValue.length];
Font font=new Font("宋体",Font.PLAIN,18);
expText.setBounds(10, 10, 240, 40);
expText.setFont(font);
expText.setBackground(Color.white);
expText.setEditable(false);// 计算式不能修改
// 设置计算结果文本框大小
resultText.setBounds(10, 50, 240, 40);
resultText.setFont(font);
resultText.setBackground(Color.white);
resultText.setHorizontalAlignment(SwingConstants.RIGHT);
resultText.setEditable(false);// 计算结果不能修改
// 设置窗口布局
this.setLayout(null);
this.add(expText); // 将计算式文本框添加到窗口中
this.add(resultText);// 将计算结果文本框添加到窗口中
// 放置按钮
int x = 10, y = 100;
for (int i = 0; i < keysValue.length; i++) {
keys[i] = new JButton();
keys[i].setText(keysValue[i]);
keys[i].setActionCommand(actionCmd[i]);
keys[i].setBounds(x, y, 60, 45);
keys[i].setFont(font);
if (x <= 130) {
x += 60;
} else {
x = 10;
y += 50;
}
this.add(keys[i]);
}
// 每个按钮都添加监听
for (int i = 0; i < keysValue.length; i++) {
keys[i].addActionListener(this);
}
// 窗口大小不能调整
this.setResizable(false);
// 设置窗口大小
this.setSize(270, 400);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
// 事件处理//递归下降法//
public void actionPerformed(ActionEvent e) {
if(e.getActionCommand().equals("0")
||e.getActionCommand().equals("1")
||e.getActionCommand().equals("2")
||e.getActionCommand().equals("3")
||e.getActionCommand().equals("4")
||e.getActionCommand().equals("5")
||e.getActionCommand().equals("6")
||e.getActionCommand().equals("7")
||e.getActionCommand().equals("8")
||e.getActionCommand().equals("9")){
expText.setText(expText.getText() + e.getActionCommand());
}
else if (e.getActionCommand().equals("+") || e.getActionCommand().equals("-")
|| e.getActionCommand().equals("*") || e.getActionCommand().equals("/")
||e.getActionCommand().equals("(") ||e.getActionCommand().equals(")")) {
// 如果点击了运算按钮，将运算符号添加到计算式文本框中
expText.setText(expText.getText() + " " + e.getActionCommand() + " ");
} else if (e.getActionCommand().equals("=")) {
// 如果点击了等号按钮，计算计算式的结果并将其显示在结果文本框中
String exp = expText.getText();
double result = eval(exp);
resultText.setText(String.valueOf(result));
} else if (e.getActionCommand().equals("CE")) {
// 如果点击了清除按钮，清除文本框中的内容
expText.setText("");
resultText.setText("0");
pos = 0;
tokens = new ArrayList<String>();
}
}
public double eval(String exp) {
/*eval() 方法接受一个字符串参数，表示要计算的表达式。
* 它首先调用 tokenize() 方法将表达式字符串分割成若干个 token，
* 然后调用 expression() 方法计算表达式的值。
* 最后，它检查是否还有剩余的token，如果有，则抛出异常。*/
// 将表达式字符串分割成若干个token
tokens = tokenize(exp);
// 调用递归函数计算表达式的值,也就是把输入在exp文本框里的字符串加入顺序表tokens
double result = expression();//利用expression()方法算出结果
// 检查是否还有剩余的 token
if (pos < tokens.size()) {
throw new RuntimeException("出现错误");
}
return result;
}
private double expression() {
/*expression() 方法计算一个表达式的值。
* 它首先调用 term() 方法计算第一个项的值，然后检查是否还有加法或减法运算符。
* 如果有，则继续调用 term() 方法计算下一个项的值，并根据运算符执行相应的操作。*/
double result = term();
while (pos < tokens.size()) {
String fh = tokens.get(pos);//读取tokens所在的pos位，如果第pos位是运算符号+，-
if (fh.equals("+") || fh.equals("-")) {//那么就先调用term()计算*/值便于实现运算符优先级
pos++;
double val = term();
if (fh.equals("+")) {
result =result + val;
} else {
result =result - val;
}
} else {
break;
}
}
return result;
}
private double term() {
/*term() 方法计算一个项的值。它首先调用 factor() 方法计算第一个因子的值，
* 然后检查是否还有乘法或除法运算符。如果有，则继续调用 factor() 方法计算下一个因子的值，
* 并根据运算符执行相应的操作。*/
double result = factor();
while (pos < tokens.size()) {
String op = tokens.get(pos);
if (op.equals("*") || op.equals("/")) {//然后检查是否还有乘法或除法运算符。
pos++;
double val = factor();
if (op.equals("*")) {
result =result * val;
} else {
result =result / val;
}
} else {
break;
}
}
return result;
}
private double factor() /*factor() 方法计算一个因子的值。它首先检查当前 token 是否为左括号
* 一元加号或一元减号。
* 如果是左括号，则递归调用 expression() 方法计算括号内的表达式的值；
* 如果是一元加号或一元减号，则递归调用 factor() 方法计算下一个因子的值，
* 并根据运算符返回相应的值；否则，将当前 token 解析为一个数字并返回。*/{
String token = tokens.get(pos++);
if (token.equals("(")) { //实现括号的优先级
double result = expression();
if (!tokens.get(pos++).equals(")")) {
throw new RuntimeException("Error: invalid expression");
}
return result;
} else if (token.equals("+") || token.equals("-")) {
double val = factor();//如果是一元加号或一元减号，则递归调用 factor() 方法计算下一个因子的值，
if (token.equals("+")) {
return +val;
} else {
return -val;
}
} else {
return Double.parseDouble(token); //返回结果
}
}
private ArrayList<String> tokenize(String exp)
/*tokenize() 方法将表达式字符串分割成若干个 token。
它遍历表达式字符串中的每个字符，如果遇到空格则忽略；如果遇到数字，
则继续向后扫描直到遇到非数字字符，并将这些数字字符组成的字符串添加到 token 列表中；
否则，将当前字符作为一个 token 添加到 token 列表中。*/{
ArrayList<String> tokens = new ArrayList<>();
int i = 0;
while (i < exp.length()) {
char ch = exp.charAt(i);
if (ch == ' ') {
i++; //若是判断到空格，则判断下一位是否为数字或者运算符
} else if (Character.isDigit(ch)) {
int j = i + 1;//一遇到运算数字 例如5678+ 7 则判断5是否为数字，如果是的话
while (j < exp.length() && Character.isDigit(exp.charAt(j)))
j++; //则利用循环判断5的后一位是否为数字，如上如果判断了6是数字则判断7
//直到判断到了运算符,停止循环
tokens.add(exp.substring(i, j));//直接将检查出来数的加入顺序表tokens
i = j;//交换i,j达成检查后一位的目的
} else {
tokens.add(String.valueOf(ch)); //如果ch不为数字而是运算符，则把运算符加入顺序表
i++; //若是输入5678 + 7 则顺序表应该是["5678","+","7"]
}
}
return tokens;
}
// 主函数
public static void main(String[] args) {
new Calculator();
}
}
此次展示到此为止
谢谢大家
