java小小工具第四弹 计算器（括号运算）

最新推荐文章于 2023-03-18 13:50:30 发布
最新推荐文章于 2023-03-18 13:50:30 发布
阅读量3.8k 收藏 22
点赞数 4
分类专栏： java简易小工具 文章标签： java课程设计 计算器 Tag
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jrdgogo/article/details/50784319
版权
/*
 * 本版计算器设计括号运算
 * 利用集合来进行遍历运算
 * 输入处理并未完善，存在bug（输入运算公式合理，便能运算出结果）

 */


package cn.hncu.mytoolkit;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.print.attribute.TextSyntax;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.Border;

import cn.hncu.set.MySet;

public class MyJsq extends JFrame {
	private JMenu[] menu;
	private JMenuItem[] menuItem;
	private JButton[] button;
	private JTextField textFieldShow,textFieldIn;
	private MySet mySet=new MySet();
	
	private ActionListener btnListener=new ActionListener() {
		//输入处理标记
		private boolean flagPoint=true;
		private boolean flagMessage=false;
		private boolean[] flagBracket=new boolean[0];
		private boolean flagRightBracket=false;
		private String Message="";
		@Override
		public void actionPerformed(ActionEvent e) {
			
			
			//输入处理
			if(flagMessage){
				textFieldIn.setText(Message);
				flagMessage=false;
				return;
			}
			String text=((JButton)e.getSource()).getText();
			
			//标签转换
			if(text.equals("=")){
				button[4].setText("CE");
			}else{
				button[4].setText("←");
			}
				
			//)括号后需接运算连接符
			if(flagRightBracket&&!(isSymbol(text)||text.equals("←")||text.equals("="))){
				message();
				textFieldIn.setText(")后需运算连接符");
				return;
			}else{
				flagRightBracket=false;
			}
			
			//数据处理
			//0的处理
			if(text.equals("0")){
				if(textFieldIn.getText().equals("0"));
				else
					textFieldIn.setText(textFieldIn.getText()+text);
					return;
			}
			//.的处理
			else if(text.equals(".")){
				//小数点不能多次出现
				if(!flagPoint){
					Toolkit.getDefaultToolkit().beep();
					return;
				}
				flagPoint=false;
				textFieldIn.setText(textFieldIn.getText()+text);
				return;
			}
			//数字处理
			else if(text.charAt(text.length()-1)>='1'&&text.charAt(text.length()-1)<='9'){
				if(textFieldIn.getText().equals("0"))
					textFieldIn.setText(text);
				else
					textFieldIn.setText(textFieldIn.getText()+text);
				return;
			}
			//删除处理
			else if(text.equals("←")){
				//删除小数点时恢复
				if(textFieldIn.getText().lastIndexOf(".")==textFieldIn.getText().length()-1)
					flagPoint=true;
				//不为0时删除末位
				if(!textFieldIn.getText().equals("0"))
					textFieldIn.setText(textFieldIn.getText().substring(0, textFieldIn.getText().length()-1));
				//为0时删除上一个数
				if(textFieldIn.getText().equals("0")){
					//有上一个数，则删
					if(mySet.size()>0){
						String str=mySet.get(mySet.size()-1).toString();
						if(str.length()>1)//多位数时
							textFieldIn.setText(str.substring(0, str.length()-1));
						else
							textFieldIn.setText("0");
						mySet.remove(mySet.size()-1);//移除上一位数
						textFieldShow.setText("");
						for (int i = 0; i < mySet.size(); i++) {
							textFieldShow.setText(textFieldShow.getText()+" "+mySet.get(i).toString());
						}
					}else
						textFieldIn.setText("0");
				}
				if(textFieldIn.getText().equals("0")){
					if(mySet.size()>0&&mySet.get(mySet.size()-1).toString().equals(")")){
						flagRightBracket=true;
					}
				}
				//删完则赋0
				if(textFieldIn.getText().equals(""))
					textFieldIn.setText("0");
				//有小数点则取消小数点
				if(textFieldIn.getText().lastIndexOf(".")>=0)
					flagPoint=false;
				return;
			}
			//清零处理
			else if(text.equals("CE")){
				textFieldIn.setText("0");
				textFieldShow.setText("");
				mySet.removeAll();
				button[4].setText("←");
				return;
			}
			
			//小数点合理性处理
			flagPoint=true;
			if(text.indexOf(".")==text.length()-1)
				text.substring(0, text.length()-1);
			
			//双目运算符处理
			if(isSymbol(text)){
				boolean falg=false;
				if(textFieldIn.getText().equals("0")||Double.parseDouble(textFieldIn.getText())==0){
					if(mySet.size()<1)
						return;
					String s=mySet.get(mySet.size()-1).toString();
					if(s.equals("(")){
						falg=false;
						message();
						textFieldIn.setText("(后需接数字");
					}else if(s.equals(")")){
						falg=true;
					}
					else
						falg=mySet.remove(mySet.size()-1);
				}
				else
					falg=mySet.add(textFieldIn.getText());
				if(falg){
					operationHandle(text);
				}
				return;
			}
			//括号处理
			else if(text.equals("(")||text.equals(")")){
				if(text.equals("(")){
					if(textFieldIn.getText().equals("0")){
						if(mySet.size()>0&&!isSymbol(mySet.get(mySet.size()-1).toString())){
							message();
							textFieldIn.setText("(前需运算连接符");
						}else{
							operationHandle(text);
							//记录括号次数
							flagBracket=new boolean[flagBracket.length+1];
						}
					}else{
						message();
						textFieldIn.setText("(前需运算连接符");
					}
				}else{
					if(flagBracket.length<1){
						message();
						textFieldIn.setText("前无(括号");
					}else{
						mySet.add(textFieldIn.getText());
						operationHandle(text);
						flagBracket=new boolean[flagBracket.length-1];
						flagRightBracket=true;
					}
				}
				return;
			}
			//开方处理
			else if(text.equals("√")){
//				if(textFieldIn.getText().equals("0")){
//					if(isSymbol(mySet.get(mySet.size()-1).toString())){
//						mySet.add(textFieldIn.getText());
//					}
//				}
//				else
//					mySet.add(""+Math.pow(Double.parseDouble(textFieldIn.getText()), 1/2));
			}
			//1/x处理
			else if(text.equals("1/x")){
				
			}
			
			
			//结果处理
			if(text.equals("=")){
				if(mySet.size()>0&&isSymbol(mySet.get(mySet.size()-1).toString())){
					mySet.add(textFieldIn.getText());
					operationHandle(text) ;
				}
				
				String[] strs=new String[mySet.size()];
				for (int i = 0; i < mySet.size(); i++) {
					if(!mySet.get(i).toString().equals("="))
						strs[i]=mySet.get(i).toString();
				}
				String strTextField=handle(strs);
				textFieldIn.setText(strTextField);
//				int indix=strTextField.indexOf(".");
//				if(indix==-1)
//					textFieldIn.setText(strTextField);
//				else{
//					if(indix+3<strTextField.length())
//						textFieldIn.setText(strTextField.substring(0, indix+3));
//					else{
//						textFieldIn.setText(strTextField);
//					}
//				}
			}
		}
		private boolean isSymbol(String text) {
			return text.equals("+")||text.equals("-")||text.equals("*")||text.equals("/")||text.equals("%")||text.equals("^");
		}
		//错误提示
		private void message() {
			Toolkit.getDefaultToolkit().beep();
			flagMessage=true;
			Message=textFieldIn.getText();
		}
        //输入处理
		private void operationHandle(String text) {
			mySet.add(text);
			textFieldShow.setText("");
			for (int i = 0; i < mySet.size(); i++) {
				textFieldShow.setText(textFieldShow.getText()+" "+mySet.get(i).toString());
			}
			textFieldIn.setText("0");
		}
        //计算处理
		private String handle(String[] strs) {
			//处理括号
			whileBracket:while (true) {
				//找到最先的一组（）
				int[][] numBracket = new int[0][];
				for (int i = 0; i < strs.length; i++) {
					if (strs[i] != null)
						if (strs[i].equals("(")) {
							int[][] numBra = new int[numBracket.length + 1][2];
							for (int k = 0; k < numBra.length; k++) {
								numBra[k][0] = -1;
								numBra[k][1] = -1;
							}
							for (int k = 0; k < numBracket.length; k++) {
								numBra[k][0] = numBracket[k][0];
								numBra[k][1] = numBracket[k][1];
							}
							numBra[numBra.length - 1][0] = i;
							numBracket = numBra;
						} else if (strs[i].equals(")")) {
							for (int k = numBracket.length - 1; k >= 0; k--) {
								if (numBracket[k][0] != -1
										&& numBracket[k][1] == -1) {
									numBracket[k][1] = i;
									break;
								}
							}
							if (numBracket[0][0] != -1
									&& numBracket[0][1] != -1)
								break;
						}
				}
				if (numBracket.length > 0) {
					String[] strBracket = new String[numBracket[0][1]
							- numBracket[0][0] - 1];
					strs[numBracket[0][0]] = null;
					strs[numBracket[0][1]] = null;
					for (int k = numBracket[0][0] + 1; k < numBracket[0][1]; k++) {
						strBracket[k - numBracket[0][0] - 1] = strs[k];
						strs[k] = null;
					}
					strs[numBracket[0][0]] = handle(strBracket);
				}
				for (int j = 0; j < strs.length; j++) {
					if(strs[j]!=null)
					if(strs[j].equals("(")){
						break;
					}
					if(j ==strs.length-1)
						break whileBracket;
				}
			}
		//优先级搞得/*%等运算先进行运算
			for (int i = 0; i < strs.length; i++) {
				if(strs[i]!=null)
					if(strs[i].equals("*")||strs[i].equals("/")||strs[i].equals("%")||strs[i].equals("^")){
						String first=strs[i-1];
						strs[i-1]=null;
						String end=strs[i+1];
						strs[i+1]=null;
						int count=2;
						while(first==null||end==null){
							if(first==null){
								first=strs[i-count];
								strs[i-count]=null;
							}
							if(end==null){
								end=strs[i+count];
								strs[i+count]=null;
							}
							count++;
						}
						if(strs[i].equals("*")){
							strs[i]=""+(Double.parseDouble(first)*Double.parseDouble(end));
						}else if(strs[i].equals("/")){
							strs[i]=""+(Double.parseDouble(first)/Double.parseDouble(end));
						}else if(strs[i].equals("%")){
							strs[i]=""+(Double.parseDouble(first)%Double.parseDouble(end));
						}else{
							strs[i]=""+Math.pow(Double.parseDouble(first),Double.parseDouble(end));
						}
					}
			}
			//+-运算
			for (int i = 0; i < strs.length; i++) {
				if(strs[i]!=null)
					if(strs[i].equals("+")||strs[i].equals("-")){
						String first=strs[i-1];
						strs[i-1]=null;
						String end=strs[i+1];
						strs[i+1]=null;
						int count=2;
						while(first==null||end==null){
							if(first==null){
								first=strs[i-count];
								strs[i-count]=null;
							}
							if(end==null){
								end=strs[i+count];
								strs[i+count]=null;
							}
							count++;
						}
						if(strs[i].equals("+")){
							strs[i]=""+(Double.parseDouble(first)+Double.parseDouble(end));
						}else{
							strs[i]=""+(Double.parseDouble(first)-Double.parseDouble(end));
						}
					}
			}
			for (int i = strs.length-1; i >=0; i--) {
				if(strs[i]!=null)
					return strs[i];
			}
			return null;
		}
	};
	private String[] s={"(",")","^","√","←",
			             "7","8","9","/","%",
			             "4","5","6","*","1/x",
			             "1","2","3","-","=",
			             "0",    ".","+"};	
	

	public MyJsq(){
		super("简单计算器");
		//Dimension dim=getToolkit().getScreenSize();
		setBounds(100,120,225,320);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		getContentPane().setLayout(null);
		
		//菜单
		JMenuBar bar=new JMenuBar();
		setJMenuBar(bar);
		String[] str={"查看","编辑","帮助"};
		menu=new JMenu[str.length];
		for (int i = 0; i < menu.length; i++) {
			menu[i]=new JMenu(str[i]);
			bar.add(menu[i]);
		}
		
		//布局
		
		//显示框
		textFieldIn=new JTextField("0");
		textFieldIn.setHorizontalAlignment(JTextField.RIGHT);
		textFieldIn.setEditable(false);
		textFieldIn.setFont(new Font("仿宋", Font.BOLD, 20));;
		textFieldIn.setBorder(BorderFactory.createBevelBorder(2));
		textFieldIn.setBounds(getContentPane().getX()+12, getContentPane().getY()+26, 186, 27);
		getContentPane().add(textFieldIn);
		
		textFieldShow=new JTextField();
		textFieldShow.setHorizontalAlignment(JTextField.RIGHT);
		textFieldShow.setEditable(false);
		textFieldShow.setBorder(BorderFactory.createBevelBorder(2));
		textFieldShow.setBounds(getContentPane().getX()+12, getContentPane().getY()+12, 186, 12);
		getContentPane().add(textFieldShow);
		//边框线
		JTextField textborder=new JTextField();
		textborder.setEditable(false);
		textborder.setBounds(getContentPane().getX()+10, getContentPane().getY()+10, 192, 45);
		getContentPane().add(textborder);
		
		
		//按钮
		button=new JButton[s.length];
		int i = 0;
		for (; i < button.length; i++) {
			button[i]=new JButton(s[i]);
			button[i].setMargin(new Insets(0,0,0,0));
			getContentPane().add(button[i]);
			if(i<19)
				button[i].setBounds(getContentPane().getX()+10+i%5*40, getContentPane().getY()+60+i/5*40, 32, 32);
			else if(i==21||i==22)
				button[i].setBounds(getContentPane().getX()+10+(i+1)%5*40, getContentPane().getY()+60+(i+1)/5*40, 32, 32);
				
			button[i].addActionListener(btnListener);
		}
		button[19].setBounds(getContentPane().getX()+10+19%5*40, getContentPane().getY()+60+19/5*40, 32, 72);
		button[20].setBounds(getContentPane().getX()+10+20%5*40, getContentPane().getY()+60+20/5*40, 72, 32);
		
		setVisible(true);
	}

	public static void main(String[] args) {
		new MyJsq();
	}
}


听听丶
关注
  • 4
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java简易计算器（四则运算、三角函数、实现优先级）
02-27
java简易计算器，能够进行四则运算、三角函数运算，已实现优先级。 将中缀表达式转化成后缀表达式（逆波兰表达式） 主要运用了栈、简单的数学知识，java图形界面设计等相关知识
Java编写的计算器图形界面实现加减乘除带括号运算
09-05
Java编写的计算器图形界面实现加减乘除带括号运算 版本1.0 1、图形化界面 2、计算器显示部分分为两个区域：第一行显示输入将要计算的数值及符号，第二行显示结果，第一行字体要小，第二行字体要大，且加粗。 ...
Java数据结构-计算器中的括号处理
vintind的博客
01-12 553
数据结构-计算器后缀表达式
【java的排序、求和、求质数、求奇数以及一些简单工具】
Leoon123的博客
03-18 229
java工具及排序，求质数，求和、查找偶数、查询奇数等
用Java来实现一个简易计算器
软件程序媛的博客
01-01 1063
设计一个计算器，弹出窗口。 import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; public class calculate { TextField tfRes
java实现计算器（带括号）
weixin_40604709的博客
08-19 1010
java实现带括号的计算器，可以对财务输入公式动态获取相应的结果
JAVA 用Steam求和
Mengxinxiaobaia的博客
08-16 7468
JAVA 优雅的使用Stream求和
表达式型计算器_java_java_括号运算_堆栈_计算器_
10-01
java算术表达式型运算器，支持四则运算、开方、括号，命令行形式运行
java实现计算器数学运算
12-11
输入一堆字符串。包括加、减、乘、除、括号。得到运算结果
10.1calculator_QT；计算器；四则运算；括号；_
09-30
一个基础的双栈带括号的基础计算器，通过QT 5.12实现可视化界面。
带括号的JAVA计算器
06-14
用java实现的简单计算器，是在Eclipse中运行成功的。可以计算带括号的加减乘除字符串
JAVA编写计算器（支持带括号）
08-07
NULL 博文链接：https://i-mty1.iteye.com/blog/2101019
Java版计算器源代码（带括号）
05-02
Java版计算器源代码（带括号） 实现图形用户界面
Java计算器代码(带括号运算)
07-13
一个用Java实现的计算器小功能, 可以支持加减乘数, 以及括号运算
简单的求和工具
11-28
简单的求和工具,分别在第一二个文本框输入数字，单击“=”，在第三个文本框中显示前面两个加数的和
java实现的计算器逻辑，可带括号
qq_42059717的博客
11-03 1586
闲的没事写的一个计算器的核心逻辑 首先会判断算式的左括号 和 右括号是不是对等的。如果不对等则添加右括号 然后判断出来最小的括号，将里边的算式计算成数值，然后替换括号内的内容， 递归判断算式中是否有括号，如果没有了最后调用一下计算算式值的方法返回最终结果 import java.math.BigDecimal; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Stack.
CollectorUtils工具类实现求和、求平均值等方法
ego_rainki
08-12 575
CollectorUtils工具类实现求和、求平均值等方法
java 括号计算_Java实现带括号优先级的计算器
weixin_39904522的博客
02-12 981
这个计算器不仅能够进行四则运算，还支持添加括号进行优先级计算，例如下面算式：10+(2*16-20/5)+7*2=52Java源代码：1 importjava.awt.BorderLayout;2 importjava.awt.Container;3 importjava.awt.event.ActionEvent;4 importjava.awt.event.ActionListener;5 i...
Java实现的计算器(带括号和错误输入提示)
热门推荐
豌豆先生
05-13 1万+
Java写的计算器，带解析括号和防止输入错误功能
java四则运算计算器
最新发布
01-10
以下是一个简单的Java四则运算计算器的示例代码： ```java import java.util.Scanner; public class Calculator { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值