实验项目1 支持算术表达式求解的计算器

最新推荐文章于 2024-06-14 14:08:37 发布
最新推荐文章于 2024-06-14 14:08:37 发布
阅读量207 收藏 4
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/icannotaccept/article/details/121544320
版权

一.项目要求

（1）能通过设计的按钮控件输入并实现算术表达式，表达式在文本框中显示，运算结果输出显示；保存和浏览历史运算记录；

（2）能够检验算术表达式的合法性；

（3）能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符；

（4）要求交互界面友好，程序健壮。

二.项目平台

IDEA.Java Swing

三.项目实现过程

1.设计思想：
要实现完整计算式的输入并运算，就得用到计算后缀表达式的算法，和将中缀表达式转换为后缀表达式的算法。

2.算法基本思想:
从左向右遍历中缀表达式
①：遇到数字字符，直接加入后缀表达式。

②：遇到高优先级运算符，若栈为空直接入栈，若栈不为空，则将当前运算符与栈顶元素比较。

情况1  栈顶元素也为高优先级运算符：栈顶元素出栈加入后缀表达式，当前运算符入栈。这样的操作使得栈中不会出现连续的高优先级运算符。

情况2  栈顶元素为’('左括号：将当前元素入栈。

情况3  栈顶元素为低优先级运算符：将当前元素入栈。

③：遇到’(‘左括号，将左括号入栈。
④：遇到’)'右括号，将栈顶元素顺序出栈，直到栈顶元素为左括号，此时删去栈顶的左括号。

⑤：遇到低优先级运算符，若栈为空直接入栈，若栈不为空，则将当前运算符与栈顶元素比较。

计算后缀表达式

运算规则：遍历后缀表达式
①：遇到数字字符，直接入栈。

②：遇到运算符，顺序出栈两个元素（数字），进行运算，将运算结果入栈循环以上步骤最终栈中剩下的那个数字就是最终答案。

3.主要代码实现：

（1）功能按钮实现

public void actionPerformed(ActionEvent e) {
        String label = e.getActionCommand();//命令实现
        if (label == "=") {
            resultText.setText(this.b);
            History.setText(History.getText() + resultText.getText());
            String s[] = operation(this.b);
            String result = Result(s);
            this.b = result + "";
            resultText.setText(this.b);
            History.setText(History.getText() + "=" + resultText.getText() + "\n");//同步历史记录
        } else if (label == "c") {
            this.b = "";
            resultText.setText("0");
        } else if (label == ".") {
            char a = label.charAt(0);
            if (point) {//按钮失效
                return;
            } else if (b.isEmpty()) {//自动补零
                b += "0.";
                point = true;
            } else {
                char t = b.charAt(b.length() - 1);
                if (t == '+' || t == '-' || t == 'x' || t == '÷') {
                    b += "0.";
                    point = true;
                } else if (t == '.') {
                    point = true;
                } else {
                    b += ".";
                    point = true;
                }
            }
            point = false;//重置
        }else if(label=="+"||label=="-"||label=="x"||label=="÷") {//符号限制
            char s = b.charAt(b.length() - 1);
            if (!b.isEmpty() && (s == '+' || s == '-' || s == 'x' || s == '÷')) { //当已经输入一个运算符时，再次输入视为运算符更新
                b = b.substring(0, b.length() - 1) + label;
            }
            else {
                b += label;
            }
        }
        else {
            this.b = this.b + label;
            resultText.setText(this.b);
        }
    }

（2）将中缀表达式变为后缀表达式

private String[] operation(String str) {
        String s = "";
        char a[] = new char[100];
        String ans[] = new String[100];
        int top = -1, j = 0;
        /**含负数运算的实现
         *
         */
        for (int i = 0; i < str.length()-1; i++) {
            if (str.charAt(i) == '(' && str.charAt(i + 1) == '-') { //将“(-”转化为“(0-”
                str = str.substring(0, i + 1) + "0" + str.substring(i + 1, str.length());
            }
        }
        for (int i = 0; i < str.length(); i++) {
            if ("0123456789.".indexOf(str.charAt(i)) >= 0) {
                s = "";
                for (; i < str.length() && "0123456789.".indexOf(str.charAt(i)) >= 0; i++) {
                    s = s + str.charAt(i);
                }
                i--;
                ans[j] = s;
                j++;
            } else if ("(".indexOf(str.charAt(i)) >= 0) {
                top++;
                a[top] = str.charAt(i);
            } else if (")".indexOf(str.charAt(i)) >= 0) {
                for (; ; ) {
                    if (a[top] != '(') {
                        ans[j] = a[top] + "";
                        j++;
                        top--;
                    } else {
                        top--;
                        break;
                    }
                }
            } else if ("x÷".indexOf(str.charAt(i)) >= 0) {
                if (top == -1) {
                    top++;
                    a[top] = str.charAt(i);
                } else {
                    if ("x÷".indexOf(a[top]) >= 0) {
                        ans[j] = a[top] + "";
                        j++;
                        a[top] = str.charAt(i);
                    } else if ("(".indexOf(a[top]) >= 0) {
                        top++;
                        a[top] = str.charAt(i);
                    } else if ("+-".indexOf(a[top]) >= 0) {
                        top++;
                        a[top] = str.charAt(i);
                    }
                }
            } else if ("+-".indexOf(str.charAt(i)) >= 0) {
                if (top == -1) {
                    top++;
                    a[top] = str.charAt(i);
                } else {
                    if ("x÷".indexOf(a[top]) >= 0) {
                        ans[j] = a[top] + "";
                        j++;
                        a[top] = str.charAt(i);
                    } else if ("(".indexOf(a[top]) >= 0) {
                        top++;
                        a[top] = str.charAt(i);
                    } else if ("+-".indexOf(a[top]) >= 0) {
                        ans[j] = a[top] + "";
                        j++;
                        a[top] = str.charAt(i);
                    }
                }
            }
        }
        for (; top != -1; ) {
            ans[j] = a[top] + "";
            j++;
            top--;
        }
        return ans;
    }

（3）计算后缀表达式

public String Result(String str[]) {
        String Result[] = new String[100];
        int Top = -1;
        for (int i = 0; str[i] != null; i++) {
            if ("+-x÷".indexOf(str[i]) < 0) {
                Top++;
                Result[Top] = str[i];
            }
            if ("+-x÷".indexOf(str[i]) >= 0) {
                double x, y, n;
                x = Double.parseDouble(Result[Top]);
                Top--;
                y = Double.parseDouble(Result[Top]);
                Top--;
                if ("-".indexOf(str[i]) >= 0) {
                    n = y - x;
                    Top++;
                    Result[Top] = String.valueOf(n);
                }
                if ("+".indexOf(str[i]) >= 0) {
                    n = y + x;
                    Top++;
                    Result[Top] = String.valueOf(n);
                }
                if ("x".indexOf(str[i]) >= 0) {
                    n = y * x;
                    Top++;
                    Result[Top] = String.valueOf(n);
                }
                if ("÷".indexOf(str[i]) >= 0) {
                    if (x == 0) {
                        String s = "ERROR";
                        return s;
                    } else {
                        n = y / x;
                        Top++;
                        Result[Top] = String.valueOf(n);
                    }
                }
            }
        }
        return Result[Top];
    }

四.最终项目实现

项目完整代码：

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Calculator extends JFrame implements ActionListener {
    private String[] KEYS = {"c", "(", ")", "+", "7", "8", "9", "-", "4", "5", "6", "x", "1", "2", "3", "÷", ".", "0", "="};
    private JButton keys[] = new JButton[KEYS.length];
    private JTextField resultText = new JTextField("0.0");
    private String b = "";
    /**
     * @point 若正在输入运算数（即非运算符），则point生效，
     * 用于标记当前运算数是否已经输入小数点，以保证
     * 每个运算数只能有一个小数点。
     */
    private boolean point = false;
    private JTextArea History = new JTextArea();// 历史记录文本框初始值设为空
    private JLabel label = new JLabel("历史记录");
    public Calculator() {
        super("计算器");
        this.setLayout(null);//设置布局管理器为默认值
        resultText.setBounds(20, 5, 255, 40);
        resultText.setHorizontalAlignment(JTextField.RIGHT);//右对齐
        resultText.setEditable(false);
        this.add(resultText);
        History.setBounds(300, 30, 200, 250);// 设置文本框大小
        History.setAlignmentX(LEFT_ALIGNMENT);// 文本框内容左对齐
        History.setEditable(false);// 文本框不允许修改结果
        label.setBounds(300, 5, 100, 20);//设置标签位置及大小
        History.setLineWrap(true);//自动换行
        History.setWrapStyleWord(true);//换行不断字
        this.add(History);//将面板添加到总窗体中
        this.setLayout(null);
        this.add(label);
        /**设置按钮
         *
         */
        int x = 20, y = 55;//按钮布局
        for (int i = 0; i < KEYS.length; i++) {
            keys[i] = new JButton();
            keys[i].setText(KEYS[i]);
            keys[i].setBounds(x, y, 60, 40);
            if (x < 215) {
                x += 65;
            } else {
                x = 20;
                y += 45;
            }
            this.add(keys[i]);
        }
        for (int i = 0; i < KEYS.length; i++) {
            keys[i].addActionListener(this);//设置监听
        }
        this.setResizable(false);
        this.setBounds(500, 200, 520, 320);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        this.setVisible(true);
    }
    public void actionPerformed(ActionEvent e) {
        String label = e.getActionCommand();//命令实现
        if (label == "=") {
            resultText.setText(this.b);
            History.setText(History.getText() + resultText.getText());
            String s[] = operation(this.b);
            String result = Result(s);
            this.b = result + "";
            resultText.setText(this.b);
            History.setText(History.getText() + "=" + resultText.getText() + "\n");//同步历史记录
        } else if (label == "c") {
            this.b = "";
            resultText.setText("0");
        } else if (label == ".") {
            char a = label.charAt(0);
            if (point) {//按钮失效
                return;
            } else if (b.isEmpty()) {//自动补零
                b += "0.";
                point = true;
            } else {
                char t = b.charAt(b.length() - 1);
                if (t == '+' || t == '-' || t == 'x' || t == '÷') {
                    b += "0.";
                    point = true;
                } else if (t == '.') {
                    point = true;
                } else {
                    b += ".";
                    point = true;
                }
            }
            point = false;//重置
        }else if(label=="+"||label=="-"||label=="x"||label=="÷") {//符号限制
            char s = b.charAt(b.length() - 1);
            if (!b.isEmpty() && (s == '+' || s == '-' || s == 'x' || s == '÷')) { //当已经输入一个运算符时，再次输入视为运算符更新
                b = b.substring(0, b.length() - 1) + label;
            }
            else {
                b += label;
            }
        }
        else {
            this.b = this.b + label;
            resultText.setText(this.b);
        }
    }
    private String[] operation(String str) {
        String s = "";
        char a[] = new char[100];
        String ans[] = new String[100];
        int top = -1, j = 0;
        /**含负数运算的实现
         *
         */
        for (int i = 0; i < str.length()-1; i++) {
            if (str.charAt(i) == '(' && str.charAt(i + 1) == '-') { //将“(-”转化为“(0-”
                str = str.substring(0, i + 1) + "0" + str.substring(i + 1, str.length());
            }
        }
        for (int i = 0; i < str.length(); i++) {
            if ("0123456789.".indexOf(str.charAt(i)) >= 0) {
                s = "";
                for (; i < str.length() && "0123456789.".indexOf(str.charAt(i)) >= 0; i++) {
                    s = s + str.charAt(i);
                }
                i--;
                ans[j] = s;
                j++;
            } else if ("(".indexOf(str.charAt(i)) >= 0) {
                top++;
                a[top] = str.charAt(i);
            } else if (")".indexOf(str.charAt(i)) >= 0) {
                for (; ; ) {
                    if (a[top] != '(') {
                        ans[j] = a[top] + "";
                        j++;
                        top--;
                    } else {
                        top--;
                        break;
                    }
                }
            } else if ("x÷".indexOf(str.charAt(i)) >= 0) {
                if (top == -1) {
                    top++;
                    a[top] = str.charAt(i);
                } else {
                    if ("x÷".indexOf(a[top]) >= 0) {
                        ans[j] = a[top] + "";
                        j++;
                        a[top] = str.charAt(i);
                    } else if ("(".indexOf(a[top]) >= 0) {
                        top++;
                        a[top] = str.charAt(i);
                    } else if ("+-".indexOf(a[top]) >= 0) {
                        top++;
                        a[top] = str.charAt(i);
                    }
                }
            } else if ("+-".indexOf(str.charAt(i)) >= 0) {
                if (top == -1) {
                    top++;
                    a[top] = str.charAt(i);
                } else {
                    if ("x÷".indexOf(a[top]) >= 0) {
                        ans[j] = a[top] + "";
                        j++;
                        a[top] = str.charAt(i);
                    } else if ("(".indexOf(a[top]) >= 0) {
                        top++;
                        a[top] = str.charAt(i);
                    } else if ("+-".indexOf(a[top]) >= 0) {
                        ans[j] = a[top] + "";
                        j++;
                        a[top] = str.charAt(i);
                    }
                }
            }
        }
        for (; top != -1; ) {
            ans[j] = a[top] + "";
            j++;
            top--;
        }
        return ans;
    }
    public String Result(String str[]) {
        String Result[] = new String[100];
        int Top = -1;
        for (int i = 0; str[i] != null; i++) {
            if ("+-x÷".indexOf(str[i]) < 0) {
                Top++;
                Result[Top] = str[i];
            }
            if ("+-x÷".indexOf(str[i]) >= 0) {
                double x, y, n;
                x = Double.parseDouble(Result[Top]);
                Top--;
                y = Double.parseDouble(Result[Top]);
                Top--;
                if ("-".indexOf(str[i]) >= 0) {
                    n = y - x;
                    Top++;
                    Result[Top] = String.valueOf(n);
                }
                if ("+".indexOf(str[i]) >= 0) {
                    n = y + x;
                    Top++;
                    Result[Top] = String.valueOf(n);
                }
                if ("x".indexOf(str[i]) >= 0) {
                    n = y * x;
                    Top++;
                    Result[Top] = String.valueOf(n);
                }
                if ("÷".indexOf(str[i]) >= 0) {
                    if (x == 0) {
                        String s = "ERROR";
                        return s;
                    } else {
                        n = y / x;
                        Top++;
                        Result[Top] = String.valueOf(n);
                    }
                }
            }
        }
        return Result[Top];
    }
    public static void main(String arg[]) {
        Calculator c = new Calculator();
    }
}

运行界面：

 

icannotaccept
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
支持算术表达式求解的计算器
Luopiao_的博客
11-25 1498
简单计算器的实现 实验内容： 学习GUI图形界面的设计，Python Tinker或 Java Swing/Awt 或C++ QT框架，创建交互友好的应用程序； 能通过界面按钮控件输入并实现算术表达式，输入的表达式即时在控件中显示，按下“=”按钮能实现运算，并将运算结果输出在控件中显示； 要求能保存和浏览历史表达式的运算记录。 算术表达式求解，是指算术表达式中包括加、减、乘、除、括号等运算符，能求解包含括号的四则混合运算； 并且能够检验表达式的合法性。 ...
实验项目一 支持算数表达式求解的计算器
qq_45938837的博客
11-25 367
一.实验要求 （1）能通过设计的按钮控件输入并实现算术表达式，表达式在文本框中显示，运算结果输出显示；保存和浏览历史运算记录； （2)能够检验算术表达式的合法性； （3）能够实现混合运算的求解，算术表达式中包含加、减、乘、除、括号等运算符； （4）要求交互界面友好，程序健壮。 ...
实验一、支持算术表达式求解的计算器
chi_choo的博客
11-25 300
要求： （1）能通过设计的按钮控件输入并实现算术表达式，表达式在文本框中显示，运算结果输出显示；保存和浏览历史运算记录； （2）能够检验算术表达式的合法性； （3）能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符； （4）要求交互界面友好，程序健壮。 ...
indexOf 和 charAt 的用法
aa1281943201的博客
04-03 627
2. indexOf(String str,int index):返回从index位置开始查找指定字符str在字符串中第一次出现处的起始索引，如果此字符串中没有这样的字符，则返回-1。1. indexOf(String str):返回指定字符str在字符串中第一次出现处的起始索引，如果此字符串中没有这样的字符，则返回-1。第二个输出函数有两个参数，从索引为6的字符开始查找，直到找到字符串“258”的“2”所在的索引12。charAt()方法用于返回指定索引处的字符。这就是indexOf的用法。
2020-11-19
qq_51391883的博客
11-19 70
想知道这串代码是啥意思？Java中的。 if(“0123456789.”.indexOf(str.charAt(i))>=0)
C/C++课设（算术表达式求解器 / 计算器 ）
01-27
功能较为完善的算术表达式求解器 / 计算器。C/C++源码，内含使用STL和不使用STL两个版本。
6、模拟计算器.算术表达式的求解（源程序+文档+说明+总结）
06-17
3到4个程序和文档任选【问题描述】 给定一个算术表达式，通过...（2）采用栈结构进行算术表达式的求解过程； （3）能够判断算术表达式正确与否； （4）对于错误表达式给出提示； （5）对于正确的表达式给出最后的结果；
表达式求解计算器 数据结构课程设计C 栈
12-27
数据结构类型：顺序栈 功能：加减乘除括号和进制转换 不支持函数运算
数据结构课程设计 算术表达式求解
01-12
实现了小数的加减乘除，乘方，除方等等算术表达式的求解
taw-datastructure:求解算术表达式并显示其分析树的计算器
03-25
计算器该存储库是“每周一次”挑战的一部分。 本周的主题是： 写一些使用数据结构的东西。 求解算术表达式并显示其分析树的计算器。 演示：
““.indexOf()的作用,以及结果标识 1、0、-1
༺ bestcxx的专栏 ༻
01-26 3万+
"".indexOf()的作用,以及结果标识 1、0、-1, -1表示不存在，其他0、1、2···表示所查询的字符或者字符串在指定字符串中首次出现的序数位（从第0位开始计数）
mini2440中QT计算器程序
默默的努力
05-09 897
ui->m_result->setText("");     if(ui->m_x->text().isEmpty()||ui->m_y->text().isEmpty())            return;     bool ok=false;     int x=ui->m_x->text().toInt(&ok);     if(!ok)     {         ui-
String类的常用方法
weixin_52211819的博客
01-29 359
String类的常用方法 indexOf():返回指定字符的索引（下标） 例如：String str="abcdefg"; int n=str.indexOf("b");//返回的下标是整型 System.out.println(n);//返回“b”下标 输出结果:1 charAt()：返回指定索引（下标）处的字符 例如： String str="abcdefg"; char c=str.charAt(5);//返回值类型是字符型 System.out.print
Java语言编写计算器
热门推荐
BTboay
03-15 10万+
本文讲述Java图形用户界面的编写，重点讲述一个简单计算器的实现。文中程序的运行环境为Windows10 ，编译环境为MyEclipse 8.5。一个简单的计算器主要实现一下功能和要求：一：输入，输出     ①输入：允许输入带有括号的完整计算式（例 6*（3+5）-5÷2）     ②输出：输出Double类型的结果二：功能     ①：基本的加，减，乘，除，四则运算     ②：平方运算   ...
实验一 支持算术表达式求解的计算器
m0_63097591的博客
11-25 195
一、实验任务 (1) 能通过设计的按钮控件输入并实现简单算术运算，要求表达式在编辑框中显示，能将运算结果，输出在编辑框内显示； (2)能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符；并且能够识别括号，优先级正确。 (3)保存历史的表达式运算记录。 ...
简单计算器 C++语言实现 支持四则运算、取余、正负数、括号
jiezz121513的博客
05-17 4122
/* Simple calculator input from cin,output to cout 简单计算器：支持加减乘除取余、正负数、括号 主要实现： 1.两个类Token和Token_stream：将输入表达式分为单词如1.82，+，（，存储在Token类对象中，Token_stream类实现能缓存1个单词的流 2.三个实现语法的函数expression(),te...
计算器c语言代码中缀表达式,C语言实现中缀表达式求值，计算器的简单实现
weixin_33156085的博客
05-20 298
#include#includetypedef struct//操作数栈{double *top;double *base;int listsize;}List;typedef struct//操作符栈{char *top;char *base;int nodesize;}Node;int InitList(List *p)//初始化操作数栈{p->base=(double *)malloc...
历史记录搜索框
weixin_41791739的博客
05-31 490
main.xml布局 &lt;LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" an...
【仿真建模-anylogic】FlowchartPort原理解析
最新发布
zhaoyaxuan001的博客
06-14 380
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
算术表达式的求解 问题描述:给定一个算术表达式，通过c语言程序求出最后的结果。 基本要求: 1. 从键盘输入要求解的算术表达式: 2.采用栈结构进行算术表达式的求解过程;.能够判断算术表达式正确与否: 4.对于错误表达式给出提示; 5.对于正确的表达式给出最后的结果;
06-10
好的，这是一个计算器程序的基本框架，需要用到栈结构和中缀表达式转后缀表达式的算法。 首先，我们需要定义一个栈结构，可以使用数组或链表实现。栈的基本操作包括入栈、出栈、判断栈空和栈满等。 其次，需要实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值