devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java简易计算器（四则运算、三角函数、实现优先级）_java实现简单计算器四则运算,三角函数

作者：小蓝xlanll | 2024-03-20 18:35:01

赞

踩

java实现简单计算器四则运算,三角函数

本人大一新手小白一枚，今天是我开通博客的第一天，发个java计算器纪念一下。

诸位有意见可以提，有不懂的也可以问，但不保证才疏学浅的博主能回答上来闭嘴闭嘴

希望以后能和你们一起共同进步，共勉！奋斗

先放上博主的代码

下面的是界面和一部分运算代码：

  1. import java.awt.*;
  2. import javax.swing.*;
  3. import java.awt.event.*;
  4. public class Calculator extends JFrame
  5. {
  6. 	static JFrame frame=new JFrame("计算器");
  7. 	JTextField display=new JTextField("0");
  8. 	Font font=new Font("Consolas",Font.BOLD,40);       //设置字体样式
  9. 	Font font1=new Font("Consolas",Font.BOLD,20);
  10. 	Image iconImage=(new ImageIcon("C:\\Study\\eclipse-workspace\\Calculator\\src\\计算器2.png")).getImage();
  11. 	ImageIcon iconImage2=new ImageIcon("C:\\Study\\eclipse-workspace\\Calculator\\src\\删除.png");
  12. 	actionlistener al=new actionlistener();//创建监听器action listener的对象
  13. 	
  14. 	//计算器按键
  15. 	JButton button_clear=new JButton("C");
  16. 	JButton button_delete=new JButton(iconImage2);
  17. 	JButton button_plus=new JButton("+");
  18. 	JButton button_minus=new JButton("-");
  19. 	JButton button_multiply=new JButton("*");
  20. 	JButton button_divide=new JButton("/");
  21. 	JButton button_spot=new JButton(".");
  22. 	JButton button_is=new JButton("=");
  23. 	JButton button_sin=new JButton("sin");
  24. 	JButton button_cos=new JButton("cos");
  25. 	JButton button_tan=new JButton("tan");
  26. 	JButton button_log=new JButton("log");
  27. 	JButton button_bracket_r=new JButton("(");
  28. 	JButton button_bracket_l=new JButton(")");
  29. 	JButton[] button=new JButton[10];
  30. 	
  31.     public Calculator()
  32.     {
  33.     	super();
  34.     	
  35.     	//设置按钮颜色字体和监听器
  36. 		 for (int i = 0; i < 10; i++) 
  37. 		 {
  38. 	         button[i] = new JButton(""+i);
  39. 	         button[i].setBackground(Color.white);//设置按钮颜色
  40. 	         button[i].setFont(font1);            //设置按钮字体
  41. 	         button[i].addActionListener(al);     //注册监听器
  42. 	     }
  43. 			//设置按钮颜色
  44. 			button_plus.setBackground(Color.white);
  45. 			button_is.setBackground(Color.pink);
  46. 			button_minus.setBackground(Color.white);
  47. 			button_multiply.setBackground(Color.white);
  48. 			button_divide.setBackground(Color.white);
  49. 			button_spot.setBackground(Color.white);
  50. 			button_clear.setBackground(Color.white);
  51. 			button_delete.setBackground(Color.white);
  52. 			button_sin.setBackground(Color.white);
  53. 			button_cos.setBackground(Color.white);
  54. 			button_tan.setBackground(Color.white);
  55. 			button_log.setBackground(Color.white);
  56. 			button_bracket_r.setBackground(Color.white);
  57. 			button_bracket_l.setBackground(Color.white);
  58. 			//设置按键透明
  59. 			button_sin.setOpaque(false);
  60. 			button_cos.setOpaque(false);
  61. 			button_log.setOpaque(false);
  62. 			button_tan.setOpaque(false);
  63. 			button_plus.setOpaque(false);
  64. 			button_minus.setOpaque(false);
  65. 			button_multiply.setOpaque(false);
  66. 			button_divide.setOpaque(false);
  67. 			button_spot.setOpaque(false);
  68. 			//设置按钮字体
  69. 			button_plus.setFont(font1);
  70. 			button_is.setFont(font1);
  71. 			button_minus.setFont(font1);
  72. 			button_multiply.setFont(font1);
  73. 			button_divide.setFont(font1);
  74. 			button_spot.setFont(font1);
  75. 			button_clear.setFont(font1);
  76. 			button_delete.setFont(font1);
  77. 			button_sin.setFont(font1);
  78. 			button_cos.setFont(font1);
  79. 			button_tan.setFont(font1);
  80. 			button_log.setFont(font1);
  81. 			button_bracket_r.setFont(font1);
  82. 			button_bracket_l.setFont(font1);
  83.     
  84. 		//计算器界面布局
  85. 		frame.setIconImage(iconImage);
  86. 		display.setHorizontalAlignment(JTextField.RIGHT);
  87. 		display.setFont(font);
  88. 		display.setBackground(Color.white);
  89. 		display.setEditable(false);          //设置文本框不可编辑
  90. 		
  91. 		JPanel pan1=new JPanel();                       //设置文本框布局
  92. 		pan1.setLayout(new GridLayout(1,1,5,5));
  93. 		pan1.setBorder(BorderFactory.createEmptyBorder(5, 5, 0, 5));
  94. 		pan1.add(display);
  95. 		
  96. 		JPanel panBody=new JPanel();                    //将按键加入panBody中
  97. 		panBody.setLayout(new GridLayout(6,4));
  98. 		panBody.add(button_clear);
  99. 		panBody.add(button_delete);
  100. 		panBody.add(button_bracket_r);
  101. 		panBody.add(button_bracket_l);
  102. 		panBody.add(button_sin);
  103. 		panBody.add(button_cos);
  104. 		panBody.add(button_tan);
  105. 		panBody.add(button_log);
  106. 		panBody.add(button[7]);
  107. 		panBody.add(button[8]);
  108. 		panBody.add(button[9]);
  109. 		panBody.add(button_plus);
  110. 		panBody.add(button[4]);
  111. 		panBody.add(button[5]);
  112. 		panBody.add(button[6]);
  113. 		panBody.add(button_minus);
  114. 		panBody.add(button[1]);
  115. 		panBody.add(button[2]);
  116. 		panBody.add(button[3]);
  117. 		panBody.add(button_multiply);
  118. 		panBody.add(button_divide);
  119. 		panBody.add(button[0]);
  120. 		panBody.add(button_spot);
  121. 		panBody.add(button_is);
  122. 		panBody.setBorder(BorderFactory.createEmptyBorder(0, 5, 5, 5));
  123. 		
  124. 		
  125. 		//创建框架窗口
  126. 		frame.setLayout(new BorderLayout());       //布局
  127. 		frame.add(pan1,BorderLayout.NORTH);
  128. 		frame.add(panBody,BorderLayout.CENTER);  
  129. 		frame.setSize(480, 380);                   //大小
  130. 		frame.setLocation(260, 150);               //位置
  131. 		frame.setVisible(true);
  132. 		frame.setResizable(false);
  133. 		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  134. 		
  135. 		//注册监听器
  136. 		button_plus.addActionListener(al);
  137. 		button_minus.addActionListener(al);
  138. 		button_multiply.addActionListener(al);
  139. 		button_divide.addActionListener(al);
  140. 		button_is.addActionListener(al);
  141. 		button_spot.addActionListener(al);
  142. 		button_clear.addActionListener(al);
  143. 		button_delete.addActionListener(al);
  144. 		button_sin.addActionListener(al);
  145. 		button_cos.addActionListener(al);
  146. 		button_tan.addActionListener(al);
  147. 		button_log.addActionListener(al);
  148. 		button_bracket_r.addActionListener(al);
  149. 		button_bracket_l.addActionListener(al);
  150. 		
  151. 	    //设置热键
  152. 	    button[0].setMnemonic(KeyEvent.VK_0);
  153. 	    button[1].setMnemonic(KeyEvent.VK_1);
  154. 	    button[2].setMnemonic(KeyEvent.VK_2);
  155. 	    button[3].setMnemonic(KeyEvent.VK_3);
  156. 	    button[4].setMnemonic(KeyEvent.VK_4);
  157. 	    button[5].setMnemonic(KeyEvent.VK_5);
  158. 	    button[6].setMnemonic(KeyEvent.VK_6);
  159. 	    button[7].setMnemonic(KeyEvent.VK_7);
  160. 	    button[8].setMnemonic(KeyEvent.VK_8);
  161. 	    button[9].setMnemonic(KeyEvent.VK_9);
  162. 	    button_delete.setMnemonic(KeyEvent.VK_BACK_SPACE);
  163. 	    button_clear.setMnemonic(KeyEvent.VK_CLEAR);
  164. 	    button_spot.setMnemonic(KeyEvent.VK_PERIOD);
  165. 	    button_is.setMnemonic(KeyEvent.VK_EQUALS);
  166. 	    button_plus.setMnemonic(KeyEvent.VK_ADD);
  167. 	    button_minus.setMnemonic(KeyEvent.VK_SUBTRACT);
  168. 	    button_multiply.setMnemonic(KeyEvent.VK_MULTIPLY);
  169. 	    button_divide.setMnemonic(KeyEvent.VK_SLASH);
  170. 	}
  171.     
  172.  
  173.     //定义处理事件的类
  174.     public class actionlistener implements ActionListener
  175.     {
  176.     	RPN rpn;
  177.     	public String pre_display="";
  178.     	public void actionPerformed(ActionEvent e)
  179.     	{
  180.     		Object click1=e.getSource();             //获得组件名称
  181.     		String click2=e.getActionCommand();      //获得组件标签
  182.     		if(click1==button_clear)                 //初始化文本框
  183.     		{
  184.     			pre_display="";
  185.     			display.setText("0");
  186.     		}
  187.     		else if(click1==button_delete)           //用handleClear()方法处理delete
  188.     		{
  189.     			if(!pre_display.equals(""))
  190.     				display.setText(handleDelete(pre_display));
  191.     			else
  192.     				display.setText(handleDelete(display.getText()));
  193.     		}
  194.     		else if(click2=="=")
  195.     		{
  196.     			//计算表达式	
  197.     			rpn=new RPN(display.getText());
  198.     			rpn.ListPreExpressionToListExpression();
  199.     			if(rpn.Opera_ListExpr().equals("illegal!"))
  200.     				display.setText("illegal!");
  201.     			else if(rpn.Opera_ListExpr().equals("non-existent!"))
  202.     				display.setText("non-existent!");
  203.     			else
  204.     			{
  205.     				double result=Double.valueOf(rpn.Opera_ListExpr()).doubleValue();
  206.     				//数据类型转换
  207.     				long t1=(long)result;
  208.     				double t2=result-t1;
  209.     				if(t2==0)
  210.     					display.setText(String.valueOf(t1));
  211.     				else
  212.     					display.setText(String.valueOf(result));
  213.     			}
  214.     				
  215.     			pre_display="";
  216.     		}
  217.     		
  218.     		else
  219.     		{
  220.     			if(click2=="tan")
  221.     				click2="tan(";
  222.     			else if(click2=="sin")
  223.     				click2="sin(";
  224.     			else if(click2=="cos")
  225.     				click2="cos(";
  226.     			else if(click2=="log")
  227.     				click2="log(";
  228.     			pre_display+=click2;
  229.     			display.setText(pre_display);
  230.     		}
  231.     	}
  232.  
  233.     	
  234.     	//退格键
  235.     	public String handleDelete(String text)
  236.     	{
  237.     		int textLength=text.length();
  238.     		if(textLength>0)
  239.     		{
  240.     			text=text.substring(0, textLength-1);     //去掉最后一个字符
  241.     			if(text.length()==0)                     //若文本框为空，则初始化为“0”
  242.     			{
  243.     				text="0";
  244.     			}
  245.     			pre_display=text;
  246.     			return text;
  247.     		}
  248.     		else
  249.     			return "illegal!";
  250.     	}
  251.     	
  252.     }
  253.     public static void main(String[] args)
  254.     {
  255.     	Calculator calculator=new Calculator();
  256.     }
  257. }

下面是逆波兰算法实现运算的代码：

  1. import java.util.ArrayList;
  2. import java.util.Stack;
  3. import java.util.StringTokenizer;
  4. public class RPN 
  5. {
  6. 	private Stack<String> StackOperator=new Stack<>();  //存放运算符的栈 
  7. 	private ArrayList<String> ListPreExpression=new ArrayList<String>(); //存放原表达式
  8. 	private ArrayList<String> ListExpression=new ArrayList<String>();   //存放逆波兰表达式
  9. 	private Stack<String> StackOperation=new Stack<>();   //运算栈
  10. 	
  11. 	//分割表达式（初始化）
  12. 	public RPN (String PreExpression)
  13. 	{
  14. 		//以+-*/（）为分割符，对原始表达式（字符串）进行分割，并返回分割符
  15. 		StringTokenizer stringTokenizer=new StringTokenizer(PreExpression,"\\+|\\-|\\*|\\/|\\(|\\)",true);
  16. 		while(stringTokenizer.hasMoreTokens())
  17. 		{
  18. 			ListPreExpression.add(stringTokenizer.nextToken());
  19. 		}
  20. 	}
  21. 			
  22. 	
  23. 	//判断是否为运算符
  24. 	public boolean isOperator(String str)
  25. 	{
  26. 		if("+-*/tancossinlog()".indexOf(str)>=0)
  27. 			return true;
  28. 		else
  29. 			return false;
  30. 	}
  31. 	
  32. 	//获取运算符的优先级
  33. 	public int getPriority(String str)
  34. 	{
  35. 		int a;
  36. 		switch(str)
  37. 		{
  38. 		case "+":
  39. 		case "-":a=1;break;
  40. 		case "*":
  41. 		case "/":a=2;break;
  42. 		case "(":a=4;break;
  43. 		case ")":a=0;break;
  44. 		case "tan":
  45. 		case "sin":
  46. 		case "cos":
  47. 		case "log":a=3;break;
  48. 		default: a=-1;break;
  49. 		}
  50. 		return a;
  51. 	}
  52. 	
  53. 	//比较优先级大小
  54. 	public boolean ComparePriority(String str1,String str2)
  55. 	{
  56. 		return getPriority(str1)>getPriority(str2);
  57. 	}
  58. 	
  59. 	//运算符入栈
  60. 	public void OperatorToStack(String str)
  61. 	{
  62. 		if(StackOperator.isEmpty())           //判断栈是否为空
  63. 			StackOperator.push(str);
  64. 		else if("(".equals(str))              //判断传入的运算符是否为"("
  65. 			StackOperator.push(str);
  66. 		else if(")".equals(str))              //判断传入的运算符是否为")"
  67. 		{
  68. 			String string;
  69. 			while(!"(".equals(string=StackOperator.pop())) //将"("和")"之间的操作符存放到ListExpression中
  70. 				ListExpression.add(string);
  71. 		}
  72. 		else if("(".equals(StackOperator.peek()))  //若栈顶元素为（，运算符直接入栈
  73. 			StackOperator.push(str);
  74. 		else if(ComparePriority(str,StackOperator.peek()))//若str优先级大于栈顶元素则入栈
  75. 			StackOperator.push(str);
  76. 		else if(!ComparePriority(str,StackOperator.peek()))//若小于则将栈顶元素弹出，str与下一个元素比较
  77. 		{
  78. 			ListExpression.add(StackOperator.pop());
  79. 			OperatorToStack(str);
  80. 		}
  81. 	}
  82. 	
  83. 	
  84. 	//中缀表达式转换成后缀表达式
  85. 	public void ListPreExpressionToListExpression()
  86. 	{
  87. 		for(String str:ListPreExpression)         //遍历ListPreExpression，运算符加入OperatorToStack,数字加入ListExpression
  88. 		{
  89. 			if(isOperator(str))
  90. 				OperatorToStack(str);
  91. 			else
  92. 				ListExpression.add(str);
  93. 		}
  94. 	
  95. 	//遍历完原始表达式后，将StackOperator栈内的运算符全部添加到ListExpression中
  96. 		while(!StackOperator.isEmpty())
  97. 		{
  98. 			ListExpression.add(StackOperator.pop());
  99. 		}
  100. 	}
  101. 	
  102. 	
  103. 	//计算方法
  104. 	
  105. 	//双目运算
  106. 	public int open=0;//用于判断输入是否正确
  107. 	public double Operation2(String str1,String str2,String str3)
  108. 	{
  109. 		double num1,num2;
  110. 		num2=Double.valueOf(str1).doubleValue();
  111. 		num1=Double.valueOf(str2).doubleValue();
  112. 		if(str3.equals("+"))
  113. 			return num1+num2;
  114. 		else if(str3.equals("-"))
  115. 			return num1-num2;
  116. 		else if(str3.equals("*"))
  117. 			return num1*num2;
  118. 		else
  119. 		{
  120. 			if(num2==0)           //除数为零时，open=1，后面会对open=1进行输出“illegal”。
  121. 				open=1;
  122. 			return num1/num2;
  123. 		}
  124. 	}
  125. 	
  126. 	//单目运算
  127. 	public double Operation1(String str1,String str2)
  128. 	{
  129. 		double num1;
  130. 		num1=Double.valueOf(str1).doubleValue();
  131. 		if(str2.equals("tan"))
  132. 		{
  133. 			if(num1==90)           //tan（90）不存在，open=2，其后的代码会输出“non-existent!"
  134. 				open=2;
  135. 			return 1;
  136. 		}
  137. 		else if(str2.equals("sin"))
  138. 			return Math.sin(num1);
  139. 		else if(str2.equals("cos"))
  140. 			return Math.cos(num1);
  141. 		else
  142. 			return Math.log(num1);
  143. 		
  144. 	}
  145. 	
  146. 	//计算逆波兰表达式
  147. 	public String Opera_ListExpr()
  148. 	{
  149. 		int open2=0;         //用于判断输入是否正确
  150. 		for(String str:ListExpression)
  151. 		{
  152. 			if(str.equals("(")||str.equals(")"))      //若ListExpression中含有括号，则报错
  153. 				open2=1;
  154. 			else if(!isOperator(str))          //把数字存放进运算栈中
  155. 				StackOperation.push(str);
  156. 			else if("tansincoslog".indexOf(str)>=0)    //tan、sin、cos、log进行单目运算
  157. 				StackOperation.push(String.valueOf(Operation1(StackOperation.pop(),str)));
  158. 			else
  159. 				//其它运算符进行双目运算
  160. 				StackOperation.push(String.valueOf(Operation2(StackOperation.pop(),StackOperation.pop(),str)));
  161. 		}
  162. 		if(open==1||open2==1)
  163. 		{
  164. 			open=0;
  165. 			return "illegal!";
  166. 		}
  167. 		else if(open==2)
  168. 		{
  169. 			open=0;
  170. 			return "non-existent!";
  171. 		}
  172. 		else
  173. 			return StackOperation.pop();
  174. 	}
  175. 	
  176. 	
  177. 	public static void main(String[] args)
  178. 	{
  179.  
  180. 	}
  181. }

希望能够帮到各位，也欢迎各位给我提提建议，谢谢啦~

 

源代码链接：

  • 百度网盘：

链接：https://pan.baidu.com/s/1M8Bfi1K7KhOP5ZNitK-N3g 
提取码：kbbe 

  • csdn下载：

https://download.csdn.net/download/sylvia_17/10979460

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/275738
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号