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

计算器——Java实现_java实现计算器

作者：花生_TL007 | 2024-03-20 18:47:44

赞

踩

java实现计算器

目录

前言

实验要求：

​编辑 界面效果：

 实现计算器类与方法：

前言

为完成数据结构实训课作业，而写的计算器。

实验要求：

 界面效果：

 实现计算器类与方法：

该计算器主要由三大类实现：Calculator,Calculate,以及Stack(老师要求自己写一个数据结构类型（我使用是链式存储）);

Calculator类：我主要实现了界面的组件的定义，组合，以及添加事件监听器，以及AC，BaskSpace0，1，2等实现相关组件功能的实现。

代码实现：

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.ActionEvent;
  4. import java.awt.event.ActionListener;
  5.  
  6. public class Calculator {
  7.     //定义基本组件
  8.     JFrame frame=new JFrame("计算器");
  9.     JPanel p1=new JPanel();
  10.     JPanel p2=new JPanel();
  11.     JPanel p3=new JPanel();
  12.     TextArea ta=new TextArea(3,40);
  13.     TextArea showTa=new TextArea("历史记录\n",14,20);
  14.     //组装组件，并添加对应方法
  15.     public void init() {
  16.         //添加组件
  17.         p1.add(ta);
  18.         p3.add(showTa);
  19.  
  20.         p2.setLayout(new GridLayout(5,4,4,4));
  21.         ActionListener actionListener=new ActionListener() {
  22.             @Override
  23.             public void actionPerformed(ActionEvent e) {
  24.                 String command=e.getActionCommand();
  25.                 ta.append(command);
  26.             }
  27.         };
  28.         p2.add(new JButton(new AbstractAction("AC") {
  29.             @Override
  30.             public void actionPerformed(ActionEvent e) {
  31.                 ta.setText("");
  32.             }
  33.         }));//清空（计算器显示屏中的内容）
  34.         p2.add(new JButton(new AbstractAction("BackSpace") {
  35.             @Override
  36.             public void actionPerformed(ActionEvent e) {
  37.                 String s=ta.getText();
  38.                 //如果ta中字符串长度不为0，则可以进行回撤;
  39.                 if(s.length()!=0){
  40.                     ta.setText(s.substring(0,s.length()-1));
  41.                 }
  42.             }
  43.         }));
  44.         p2.add(actionBtn(new JButton("("),actionListener));
  45.         p2.add(actionBtn(new JButton(")"),actionListener));
  46.  
  47.         for (int i = 7; i < 10; i++) {
  48.             p2.add(actionBtn(new JButton(i+""),actionListener));
  49.         }
  50.         p2.add(actionBtn(new JButton("+"),actionListener));
  51.  
  52.         for(int i=4;i<=6;i++){
  53.             p2.add(actionBtn(new JButton(i+""),actionListener));
  54.         }
  55.         p2.add(actionBtn(new JButton("-"),actionListener));
  56.  
  57.         for (int i=1;i<=3;i++){
  58.             p2.add(actionBtn(new JButton(""+i),actionListener));
  59.         }
  60.         p2.add(actionBtn(new JButton("x"),actionListener));
  61.         p2.add(actionBtn(new JButton("."),actionListener));
  62.  
  63.         p2.add(actionBtn(new JButton("0"),actionListener));
  64.         p2.add(actionBtn(new JButton("/"),actionListener));
  65.         JButton btn_equal=new JButton(new AbstractAction("=") {
  66.             @Override
  67.             public void actionPerformed(ActionEvent e) {
  68.                 String s=ta.getText();
  69.                 Calculate calculate=new Calculate();
  70.                 String result=calculate.evaluate(s);
  71.                 showTa.append(s+"="+result+"\n");
  72.                 ta.setText(result);
  73.  
  74.             }
  75.         });
  76.         //窗口内组件布局的设置
  77.         p2.add(btn_equal);
  78.         Box left_box=Box.createVerticalBox();
  79.         left_box.add(p1);
  80.         left_box.add(p2);
  81.         Box box=Box.createHorizontalBox();
  82.         box.add(left_box);
  83.         box.add(p3);
  84.         frame.add(box);
  85.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭计算器窗口
  86.         frame.pack();//设置窗口合适的大小
  87.         frame.setVisible(true);//显示窗口
  88.  
  89.     }
  90.     public static void main(String[] args) {
  91.         // TODO 自动生成的方法存根
  92.         //调用init()方法
  93.         new Calculator().init();
  94.  
  95.     }
  96.     //给按钮添加事件监听器
  97.     public JButton actionBtn(JButton btn,ActionListener actionListener){
  98.         btn.addActionListener(actionListener);
  99.         return btn;
  100.     }
  101.  
  102. }

Calculate类：本类也是代码最核心的地方，主要实现本项目最核心的部分，里面包含很多逻辑关系，利用栈的思想，实现计算器+,-,x,/,=,以及带有小数点，负数，与（）（括号）等实现。代码中有很多值得被考虑：如：优先级问题，除法分母不为0等问题。都值得大家慢慢体会！！

代码实现: 

  1. import java.math.BigDecimal;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. //import java.util.Stack;
  5. public class Calculate {
  6.  
  7.     public String evaluate(String express) {
  8.         String expression = express;
  9.         double calculate = 0;
  10.         try {
  11.             List<String> infixExpression = depositList(expression);//中缀表达式
  12.             List<String> calculateExpression = parsExpression(infixExpression);//后缀表达式
  13.             calculate = calculate(calculateExpression);
  14.         }catch (RuntimeException e){
  15.             return "error";
  16.         }
  17.         if (calculate==0){
  18.             return "0";
  19.         } else {
  20.             BigDecimal bigDecimal = new BigDecimal(String.format("%.12f",calculate));//去掉前面多余的零
  21.             String result = bigDecimal.toString();
  22.             if(result.indexOf(".")>0){
  23.                 result = result.replaceAll("0+?$","");//去掉后面无用的零
  24.                 result = result.replaceAll("[.]$","");//如小数点后面全是零去掉小数点
  25.             }
  26.             return result;
  27.         }
  28.     }
  29.  
  30.  
  31.     public static List<String> parsExpression(List<String> list) {//方法：将得到的中缀表达式对应的转换后缀表达式对应的List
  32.         //定义两个栈
  33.         Stack<String> s1 = new Stack<String>(); // 符号栈
  34.         List<String> s2 = new ArrayList<String>(); // 储存中间结果的Lists2
  35.  
  36.  
  37.         for(String item: list ) {
  38.             if(item.matches("^[1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*|[1-9]\\d*|0|-[1-9]\\d*\\.\\d*|-0\\.\\d*|-[1-9]\\d*$")) {//如果是一个数加入s2
  39.                 s2.add(item);
  40.             } else if (item.equals("(")) {
  41.                 s1.push(item);
  42.             } else if (item.equals(")")) {
  43.  
  44.                 while(!s1.peek().equals("(")) {//如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
  45.                     s2.add(s1.pop());
  46.                 }
  47.                 s1.pop();//将 ( 弹出 s1栈， 消除小括号
  48.             } else {
  49.                 while(s1.size() != 0 && operation.getValue(s1.peek()) >= operation.getValue(item) ) {
  50.                     s2.add(s1.pop());
  51.                 }
  52.  
  53.                 s1.push(item);
  54.             }
  55.         }
  56.  
  57.  
  58.         while(s1.size() != 0) {	//将s1中剩余的运算符依次弹出并加入s2
  59.             s2.add(s1.pop());
  60.         }
  61.  
  62.         return s2;
  63.  
  64.     }
  65.  
  66.     public static List<String> depositList(String s) {
  67.  
  68.         List<String> list = new ArrayList<String>();//定义一个List,存放中缀表达式 对应的内容
  69.         int i = 0;
  70.         String str;
  71.         char c;
  72.         do {
  73.             boolean isMinus = false;
  74.             if ((c=s.charAt(i))=='-'){
  75.                 if (i==0 || s.charAt(i-1)=='('){
  76.                     isMinus=true;
  77.                 }
  78.             }
  79.             if(((c=s.charAt(i)) < 48 ||  (c=s.charAt(i)) > 57) && !isMinus) {
  80.                 list.add("" + c);
  81.                 i++;
  82.             } else {
  83.                 str = ""; //先将str 置成"" '0'[48]->'9'[57]
  84.                 do {
  85.                     str += c;
  86.                     i++;
  87.                 }while(i < s.length() && (((c=s.charAt(i)) >= 48 && (c=s.charAt(i)) <= 57) || (c=s.charAt(i)) == '.'));
  88.                 list.add(str);
  89.             }
  90.         }while(i < s.length());
  91.         return list;
  92.     }
  93.  
  94.     public static double calculate(List<String> list) {
  95.         Stack<String> stack = new Stack<String>();// 创建栈
  96.         for (String item : list) {
  97.             if (item.matches("^[1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*|[1-9]\\d*|0|-[1-9]\\d*\\.\\d*|-0\\.\\d*|-[1-9]\\d*$")) { //使用正则表达式匹配多位数
  98.                 stack.push(item);
  99.             } else {
  100.                 double num2 = Double.parseDouble(stack.pop());	// pop出两个数，并运算， 再入栈，如果空就赋值为零是为了让负数也能算
  101.                 double num1 = Double.parseDouble(stack.pop());
  102.                 double res = 0;
  103.                 if (item.equals("+")) {
  104.                     res = num1 + num2;
  105.                 } else if (item.equals("-")) {
  106.                     res = num1 - num2;
  107.                 } else if (item.equals("x")) {
  108.                     res = num1 * num2;
  109.                 } else if (item.equals("/")&&num2!=0) {
  110.                     res = num1 / num2;
  111.                 } else {
  112.                     throw new RuntimeException("运算符有误");
  113.                 }
  114.  
  115.                 stack.push("" + res);
  116.             }
  117.  
  118.         }
  119.  
  120.         return Double.parseDouble(stack.pop());
  121.     }
  122.  
  123. }
  124. //编写一个类 Operation 可以返回一个运算符 对应的优先级
  125. class operation {
  126.     private static int Add = 1;
  127.     private static int Sub = 1;
  128.     private static int Mul = 2;
  129.     private static int Div = 2;
  130.  
  131.     //写一个方法，返回对应的优先级数字
  132.     public static int getValue(String operation) {
  133.         int result = 0;
  134.         switch (operation) {
  135.             case "+":
  136.                 result = Add;
  137.                 break;
  138.             case "-":
  139.                 result = Sub;
  140.                 break;
  141.             case "x":
  142.                 result = Mul;
  143.                 break;
  144.             case "/":
  145.                 result = Div;
  146.                 break;
  147.             default:
  148.  
  149.                 break;
  150.         }
  151.         return result;
  152.     }
  153.  
  154. }
  155.

 Stack类:该类是最底层的东西，主要通过结点链式存储方法写出的类，该类在Java.util包下就已经有该方法的实现，但在这我本人是为了完成老师的要求，才加上去的。

代码实现:

  1. public class Stack<T>  {
  2.     //记录首结点
  3.     private Node head;
  4.     //栈中元素的个数
  5.     private int N;
  6.  
  7.     public Stack() {
  8.         head = new Node(null, null);
  9.         N = 0;
  10.     }
  11.  
  12.     //判断当前栈中元素个数是否为0
  13.     public boolean isEmpty() {
  14.         return N == 0;
  15.     }
  16.  
  17.     //把t元素压入栈
  18.     public void push(T t) {
  19.         Node oldNext = head.next;
  20.         Node node = new Node(t, oldNext);
  21.         head.next = node;
  22. //个数+1
  23.         N++;
  24.     }
  25.  
  26.     //弹出栈顶元素
  27.     public T pop() {
  28.         Node oldNext = head.next;
  29.         if (oldNext == null) {
  30.             return null;
  31.         }
  32. //删除首个元素
  33.         head.next = head.next.next;
  34. //个数-1
  35.         N--;
  36.         return oldNext.item;
  37.     }
  38.     public T peek(){
  39.         if(!isEmpty()){
  40.             return head.next.item;
  41.         }
  42.         return null;
  43.     }
  44.  
  45.     //获取栈中元素的个数
  46.     public int size() {
  47.         return N;
  48.     }
  49.  
  50.     private class Node {
  51.         public T item;
  52.         public Node next;
  53.  
  54.         public Node(T item, Node next) {
  55.             this.item = item;
  56.             this.next = next;
  57.         }
  58.     }
  59. }

这篇文章到这也达到尾声了，谢谢大家阅览！最后也希望大家能够试试这计算器的功能，帮我检验它是否存在bug,如果有的话，请留言，我看到之后就一定修改。

冬天到了，春天还会远吗？

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

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

  

闽ICP备14008679号