多功能计算器（算式表达式求值）

最新推荐文章于 2021-09-08 10:06:09 发布
最新推荐文章于 2021-09-08 10:06:09 发布
阅读量449 收藏 2
点赞数
分类专栏： 算式表达式求值 计算器 文章标签： 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dennisming/article/details/106094094
版权

//java的人机界面计算器也做出来了，根据上次写的C++的计算器改的，超级有成就感，所以要记录一下，防止丢失，代码乱是乱了点，因为我把他们全部通通写进了main方法里面，省的函数调用来调用去的。不过能运行出来就是好的，嘿嘿，唯一美中不足的就是计算负数要加括号，这就很难受了

import java.awt.Color;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Stack;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextArea;
public class 人机界面计算器{
	public static void main(String [] args) {
		JFrame frm = new JFrame("计算器");
		JTextArea text = new JTextArea();
		text.setEditable(true);
		text.setBackground(Color.WHITE);
		frm.setLayout(null);
		frm.setBounds(800, 200, 460, 560);
		frm.setVisible(true);
		JButton btn0=new JButton("1");
		JButton btn1=new JButton("2");
		JButton btn2=new JButton("3");
		JButton btn3=new JButton("4");
		JButton btn4=new JButton("5");
		JButton btn5=new JButton("6");
		JButton btn6=new JButton("7");
		JButton btn7=new JButton("8");
		JButton btn8=new JButton("9");
		JButton btn9=new JButton("0");
		JButton btn10=new JButton(".");
		JButton btn11=new JButton("^");
		JButton btn12=new JButton("sin");
		JButton btn13=new JButton("cos");
		JButton btn14=new JButton("tan");
		JButton btn15=new JButton("log");
		JButton btn16=new JButton("+");
		JButton btn17=new JButton("-");
		JButton btn18=new JButton("×");
		JButton btn19=new JButton("÷");
		JButton btn20=new JButton("(");
		JButton btn21=new JButton(")");
		JButton btn22=new JButton("=");
		frm.add(text);
		frm.add(btn0);
		frm.add(btn1);
		frm.add(btn2);
		frm.add(btn3);
		frm.add(btn4);
		frm.add(btn5);
		frm.add(btn6);
		frm.add(btn7);
		frm.add(btn8);
		frm.add(btn9);
		frm.add(btn10);
		frm.add(btn11);
		frm.add(btn12);
		frm.add(btn13);
		frm.add(btn14);
		frm.add(btn15);
		frm.add(btn16);
		frm.add(btn17);
		frm.add(btn18);
		frm.add(btn19);
		frm.add(btn20);
		frm.add(btn21);
		frm.add(btn22);
		text.setBounds(50, 10, 340, 50);
		Font f = new Font("黑体", Font.BOLD,40);
		text.setFont(new Font("黑体",Font.BOLD,22));
		text.setEditable(false);
		text.setLineWrap(true);
		text.setWrapStyleWord(true);
		btn0.setBounds(50, 70, 60, 50);
		btn0.setFont(f);
		btn0.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("1");
			}
			
		});
		btn1.setBounds(130, 70, 60, 50);
		btn1.setFont(f);
		btn1.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("2");
			}
			
		});
		btn2.setBounds(210, 70, 60, 50);
		btn2.setFont(f);
		btn2.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("3");
			}
			
		});
		btn3.setBounds(50, 140, 60, 50);
		btn3.setFont(f);
		btn3.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("4");
			}
			
		});
		btn4.setBounds(130, 140, 60, 50);
		btn4.setFont(f);
		btn4.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("5");
			}
			
		});
		btn5.setBounds(210, 140, 60, 50);
		btn5.setFont(f);
		btn5.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("6");
			}
			
		});
		btn6.setBounds(50, 210, 60, 50);
		btn6.setFont(f);
		btn6.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("7");
			}
			
		});
		btn7.setBounds(130, 210, 60, 50);
		btn7.setFont(f);
		btn7.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("8");
			}
			
		});
		btn8.setBounds(210, 210, 60, 50);
		btn8.setFont(f);
		btn8.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("9");
			}
			
		});
		btn9.setBounds(130, 280, 60, 50);
		btn9.setFont(f);
		btn9.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("0");
			}
			
		});
		btn10.setBounds(50, 280, 60, 50);
		btn10.setFont(f);
		btn10.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append(".");
			}
			
		});
		btn11.setBounds(210, 280, 60, 50);
		btn11.setFont(f);
		btn11.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("^");
			}
			
		});
		btn12.setBounds(50, 350, 100, 50);
		btn12.setFont(f);
		btn12.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("sin(");
			}
			
		});
		btn13.setBounds(170, 350, 100, 50);
		btn13.setFont(f);
		btn13.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("cos(");
			}
			
		});
		btn14.setBounds(50, 420, 100, 50);
		btn14.setFont(f);
		btn14.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("tan(");
			}
			
		});
		btn15.setBounds(170, 420, 100, 50);
		btn15.setFont(f);
		btn15.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("log");
			}
			
		});
		btn16.setBounds(290, 70, 100, 50);
		btn16.setFont(f);
		btn16.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("+");
			}
			
		});
		btn17.setBounds(290, 140, 100, 50);
		btn17.setFont(f);
		btn17.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("-");
			}
			
		});
		btn18.setBounds(290, 210, 100, 50);
		btn18.setFont(f);
		btn18.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("×");
			}
			
		});
		btn19.setBounds(290, 280, 100, 50);
		btn19.setFont(f);
		btn19.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("÷");
			}
			
		});
		btn20.setBounds(290, 350, 45, 50);
		btn20.setFont(new Font("黑体",Font.BOLD,20));
		btn20.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append("(");
			}
			
		});
		btn21.setBounds(345, 350, 45, 50);
		btn21.setFont(new Font("黑体",Font.BOLD,20));
		btn21.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				text.append(")");
			}
			
		});
		btn22.setBounds(290, 420, 50, 50);
		btn22.setFont(new Font("黑体",Font.BOLD,25));
		btn22.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent arg0) {
				int Maxsize = 100;//定义数组大小
				char[] optr=new char[Maxsize];//定义optr数组，用来存放后缀表达式
				Stack<Character> Optr = new Stack<Character>();//产生栈对象Optr，用来存放运算符
				String a = null;
				a=text.getText().toString();
				String m = "("+a+")";
				char[] measure=m.toCharArray();//转换输入的字符串为数组
				int j = 0;
				 int i = 0;
				 //中缀表达式转后缀表达式
				while(i<measure.length) {
					switch(measure[i]) {
					case '(':
						Optr.push(measure[i]);
						i++;
						break;
					case ')':
						while(Optr.peek()!='(') {
							optr[j++]=Optr.peek();
							Optr.pop();
						}
						Optr.pop();
						i++;
						break;
					case '+':
						while(!Optr.isEmpty()) {
							if(Optr.peek()!='(') {
								optr[j++]=Optr.peek();
								Optr.pop();
							}
							else 
								break;
						}
						Optr.push(measure[i]);
						i++;
						break;
					case '-':
						if(measure[i-1]<'0'||measure[i-1]>'9') {//表示-前面不是数字，即此处-表示单目运算符
							while(!Optr.isEmpty()) {
								if(Optr.peek()=='*'||Optr.peek()=='/') {
									optr[j++]=Optr.peek();
									Optr.pop();
								}
								else break;
							}
							Optr.push('~');
							i++;
							break;
						}
						else {
						while(!Optr.isEmpty()) {
							if(Optr.peek()!='(') {
								optr[j++]=Optr.peek();
								Optr.pop();
							}
							else 
								break;
						}
						Optr.push(measure[i]);
						i++;
						break;}
					case 'l':
						while(!Optr.isEmpty()) {
							if(Optr.peek()=='l') {
								optr[j++]=Optr.peek();
								Optr.pop();
							}
							else break;
						}
						Optr.push(measure[i]);
						i+=3;
						break;
					case 'c':
						while(!Optr.isEmpty()) {
							if(Optr.peek()=='c') {
								optr[j++]=Optr.peek();
								Optr.pop();
							}
							else break;
						}
						Optr.push(measure[i]);
						i+=3;
						break;
					case 's':
						while(!Optr.isEmpty()) {
							if(Optr.peek()=='s') {
								optr[j++]=Optr.peek();
								Optr.pop();
							}
							else break;
						}
						Optr.push(measure[i]);
						i+=3;
						break;
					case 't':
						while(!Optr.isEmpty()) {
							if(Optr.peek()=='t') {
								optr[j++]=Optr.peek();
								Optr.pop();
							}
							else break;
						}
						Optr.push(measure[i]);
						i+=3;
						break;
					case '^':
						while(!Optr.isEmpty()) {
							if(Optr.peek()=='^') {
								optr[j++]=Optr.peek();
								Optr.pop();
							}
							else break;
						}
						Optr.push(measure[i]);
						i++;
						break;
					case '×':
					case '÷':
						while(!Optr.isEmpty()) {
							
							if(Optr.peek()=='×'||Optr.peek()=='÷') {
								optr[j++]=Optr.peek();
								Optr.pop();
							}
							else break;
						}
						Optr.push(measure[i]);
						i++;
						break;
						default:
							while(measure[i]>='0'&&measure[i]<='9'||measure[i]=='.') {
								optr[j++]=measure[i];
								i++;
							}
							optr[j++]='#';
							break;
							}
					}
				while(!Optr.isEmpty()) {
					optr[i++]=Optr.peek();
					Optr.pop();
				}

				//后缀表达式求值
				int q=1;
				Stack<Double> Opnd = new Stack<Double>();//存放操作数
				int n = 0;
				int w;
				double a1,b,c = 0;
				while(optr[n]!='\0') {
					switch(optr[n]) {
					case '+':
						a1=Opnd.peek();
						Opnd.pop();
						b=Opnd.peek();
						Opnd.pop();
						c=b+a1;
						Opnd.push(c);
						break;
					case '-':
						a1=Opnd.peek();
						Opnd.pop();
						b=Opnd.peek();
						Opnd.pop();
						c=b-a1;
						Opnd.push(c);
						break;
					case '×':
						a1=Opnd.peek();
						Opnd.pop();
						b=Opnd.peek();
						Opnd.pop();
						c=b*a1;
						Opnd.push(c);
						break;
					case '÷':
						a1=Opnd.peek();
						Opnd.pop();
						b=Opnd.peek();
						Opnd.pop();
						if(a1!=0) {
							c=b/a1;
							Opnd.push(c);
							break;
						}
						else {
							text.setFont(new Font("黑体",Font.BOLD,40));
							text.setText("除零错误");}
					case 'l':
						a1=Opnd.peek();
						Opnd.pop();
						b=Opnd.peek();
						Opnd.pop();
						c=Math.log10(b)/Math.log10(a1);
						Opnd.push(c);
						break;
					case '^':
						a1=Opnd.peek();
						Opnd.pop();
						b=Opnd.peek();
						Opnd.pop();
						c=Math.pow(b, a1);
						Opnd.push(c);
						break;
					case 'c':
						a1=Opnd.peek();
						Opnd.pop();
						c=Math.cos(a1);
						Opnd.push(c);
						break;
					case 's':
						a1=Opnd.peek();
						Opnd.pop();
						c=Math.sin(a1);
						Opnd.push(c);
						break;
					case 't':
						a1=Opnd.peek();
						Opnd.pop();
						c=Math.tan(a1);
						Opnd.push(c);
						break;
				
					case '~':
						a1=-Opnd.peek();
						Opnd.pop();
						Opnd.push(a1);
						break;
					default :
							double d = 0;
							w=0;
						while(optr[n]>='0'&&optr[n]<='9'||optr[n]=='.') {
								d=10*d+optr[n]-'0';
								n++;
								//对小数点的处理
								if(optr[n]=='.') {
									q=-1;
									n++;
									w=0;
								}
								w++;
								}
							d=d/Math.pow(10,w-1);
							if(q!=-1) {
								d=d*Math.pow(10, w-1);
							}
							q=1;
							Opnd.push(d);
							break;
							}
					n++;
					}
				text.setFont(new Font("黑体",Font.BOLD,40));
				if(Opnd.peek()%(int)c==0)text.setText("="+(int)c);
				if((Opnd.peek()%(int)c)!=0)text.setText("="+Opnd.peek());
		
			}
			
		});
		JButton btn23 = new JButton("C");
		frm.add(btn23);
		btn23.setBounds(350, 420, 40, 50);
		btn23.setFont(new Font("黑体",Font.BOLD,10));
		btn23.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				text.setFont(new Font("黑体",Font.BOLD,22));
				text.setText(null);	
			}	
		});
	}
}

//顺便附上超有成就感的运行结果，因为定义的是double类型，所以结果可想而知，就是后面跟了一连串0，哈哈
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Dennisming
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
模仿设计一个Windows计算器程序作业
05-17
模仿设计一个Windows计算器程序。作业。你们懂的，大学。
Qt 调试窗口不见了（添加到表达式求值器）关了，怎么打开？
weixin_40314351的博客
10-28 2854
程序调试的时候，可以通过右侧的窗体查看到当前文件中许多变量的值。在编程的时候，不小心把它关闭了，找了好些时间才恢复，记录一下。
1.QT Creator的使用
YW博客
09-08 324
1.蓝牙，nfc,命名空间，防止野生化 2.点击运行没有反应时候，清除，重新构建，重启 3…pro文件记录了当前项目的信息，包含哪些文件，组件 4.Qt+=gui 加入模块，内部有很多头文件，如代码中的#include 5.网络上下载了个代码，删除.user文件，记录了qt版本，qt安装目录等，删除后并没有影响，运行时会自动生成，符合自己电脑 6.运行时点上总是保存 7.运行可以运行多个单例，断点：停止，没有函数的时候，单步跳过何单步进入是一样的 8.调式的时候窗口太多，点击esc 9.Esc按多了，点击旁
QT算数表达式求值
肥宅Sean
10-08 1825
对之前的那个QT做的计算器，做一个修改。 原版本链接 有兴趣的话，可以两者结合起来，通过这个改进的过程，找到问题，进一步的提升。 新版本代码： #include "mainwindow.h" #include "ui_mainwindow.h" #include #include using namespace std; MainWindow::MainWindow(QWidget *
栈的应用之中缀表达式求值（QT平台）
08-19
本程序利用两个栈——一个符号栈一个数字栈，实现了中缀表达式的计算，代码风格是C++，运行平台是QT，欢迎大家下载参考。
多功能计算器-批量导入计算
01-16
《多功能计算器：批量导入计算详解》 在当今的数字化时代，计算器已经不再局限于简单的加减乘除，而是发展成为一种高效、便捷的计算工具。本文将深入探讨一款名为"多功能计算器"的应用，它具备批量导入计算功能，...
java 简单算式计算器
01-06
"4600071_calculator.java"文件可能包含了整个计算器的功能，但更复杂的应用可能会将功能分解到多个类中，每个类负责一部分功能，例如`Calculator`类、`InputHandler`类等。 8. **测试与调试**：在开发过程中，通过...
多功能科学计算器-分析设计报告1
08-08
【多功能科学计算器分析设计报告】 本项目旨在开发一个多功能科学计算器软件，以满足用户在学习和工作中处理复杂计算问题的需求，同时提供直观易用的界面，降低用户的学习成本。该软件设计包含六个主要模块，分别为...
C++实现计算器中的算式解析类+demo演示
06-26
通过以上步骤，我们可以构建一个功能完备的C++算式解析类，能够处理复杂的数学表达式，包括多参数的数学函数。这样的类不仅可以用于简单的计算器应用，还能在更复杂的计算环境中发挥作用。在实际项目中，可能还需要...
超越表达式计算器
01-21
　此外，超越表达式计算器还支持对多个表达式进行批量的运算，完成这个功能您只需将含有多个算式的文本复制粘贴到超越表达式计算器的文本框内即可，在粘贴的同时，计算器便会在算式中”=”号的后面写上结果。...
Qt简易计算器（带括号加减乘除）
07-06
压缩包内为完整项目文件，可直接使用 Qt version：5.14 IDE：Qt内置编译器 C++ 表达式求值方法：中缀表达式转后缀表达式，后缀表达式求值。 资源详细情况见博文：https://blog.csdn.net/qq_44977889/article/details/106888257
用delphi写的计算器
02-09
用delphi写的简单计算器，包含所有代码。放在Delphi7中即可使用
多功能表达式计算器
06-08
计算器 多功能 范式 自定义函数 +-*/^ 表达式运算 cos sin tan log exp acos....还可自定义函数 自定义常量如：#pi
表达式计算器 DLL
06-04
提供dll接口，C#,C++的调用方法见示例程序。
表达式求值计算(java实现)
11-25
对用+、-、*、/、(、）连接起来的算术表达式求值， 可以智能识别和过滤表达式。
表达式求值 （计算器）
weixin_30699443的博客
08-22 123
#include <iostream> #include <cstdio> #include <cstring> #include <cstdlib> #include <algorithm> using namespace std; const int MAX=1505; char data[MAX]; ...
计算器制作JAVA版（第三步，表达式求值(+-*/)）
WPC的专栏
03-02 1363
这个东西一直是大家关注的热点，也是这个题目的真正目标所在，希望大家能够好好学习了解这个部分的思路想法。虽然这个思路不是以后编译原理上面的标准思路，也不是什么正统方法，但是它确实符合大家的想法和一贯的思路。因为不够正统和强悍，如有高人敬请指点。那么我们来考虑一下这个表达式，如果只有加减运算符大家是否感觉能很好的解决呢？首先是单位的数字和运算符（只有加减），那么我们就只用顺序处理即可。形如：a+b-c
计算器/表达式求值
姚军
07-19 533
京东零售部618【提前批一面】 Java的常用的集合，arraylist/linkedlist/hashmap/hashset/treeset/treemap arraylist的addall方法，入参是传的啥 hashmap和线程安全的hashmap 线程同步关键字synchronized和volatile和retreenlock原理 final关键字怎么用的，可以用在方法上吗 缓存redis数据结构和设置过期时间 Java的框架springboot的主要注解 Java连接数据库的方式除了JDBC(我回
编程实现简单的计算器功能，要求用户按如下格式从键盘输入算式： 操作数1 运算符op 操作数2 计算并输出表达式的值，其中算术运算符包括：加（+）、减（-）、乘（*）、除（/）、^(次幂）。 要求使其能进行浮点数的算术运算，同时允许使用字符*、x与x作为乘号，并且允许输入的算术表达式中的操作数和运算符之间可以加入任意多个空格符。
最新发布
06-06
然后计算并输出表达式的值，其中算术运算符包括加（+）、减（-）、乘（*）、除（/）和次方（^），要求使用浮点数的算术运算，同时允许使用字符*、x和x作为乘号，且允许在输入的算式表达式中的操作数和运算符之间可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值