利用ArrayList, swing, ActionListener创造简单GUI计算器

最新推荐文章于 2021-03-01 14:23:40 发布
最新推荐文章于 2021-03-01 14:23:40 发布
阅读量205 收藏 1
点赞数
文章标签： java 数据结构与算法 操作系统
原文链接：https://segmentfault.com/a/1190000014489551
版权

废话不多说，在网上搜索了编写计算器相关的源码，要么算法低效要么不全。于是这周小编决定简单讲讲如何制作一个简易计算器，首先你要清楚GUI里要显示什么：

  1. 结果显示框
  2. 0～9的数字
  3. 删除功能
  4. 清楚功能
  5. 搜寻历史记录功能
  6. 计算结果的功能
  7. 括号优先计算功能

接下来通过流程图简单介绍一下思路：
流程图

GUI 源码

以下代码是根据我的设计来编写的

/**
 * @author Hephaest
 * @since  2018/04/19
 * JDK 1.6
 */
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.SwingConstants;
import javax.swing.UIManager;
/**
 * Calculator类用来创造GUI
 */
public class Calculator extends JFrame
{
    //新建文本框
    JTextField text = new JTextField();
    // set up row 2
    JPanel row2 = new JPanel();
    //创建按钮们
    String[][] buttons= {{"7","8","9","DEL","AC"},{"4","5","6","×","÷"},{"1","2","3","+","-"},{"0","(",")","Replay","="}};
    JButton[][]button = new JButton[4][5];
    /**
     * 这个计算机的界面我模拟的是卡西欧fx-82ES PLUS A
     * 但是仅有其中的部分功能
     */
    public Calculator()
    {
        super("CASIO");
        setSize(400,300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());
        //设置文本框的尺寸、位置以及禁止键盘输入
        text.setPreferredSize(new Dimension(30, 40));
        text.setHorizontalAlignment(SwingConstants.TRAILING);
        text.setEditable(false);
        getContentPane().add(text, BorderLayout.NORTH);
        //声明每一个按钮代表的意义
        add(row2, BorderLayout.CENTER);
        GridLayout layout2 = new GridLayout(4,5,5,5);
        row2.setLayout(layout2);
        for(int i=0;i<buttons.length;i++)
        {
            for(int j=0;j<buttons[0].length;j++)
            {
                button[i][j]=new JButton(buttons[i][j]);
                row2.add(button[i][j]);
            }
        }
        add(row2);
        setResizable(false);
        setVisible(true);
    }
    
    private static void setLookAndFeel() 
    {
        //这条使跨操作系统也能看到计算机的GUI
        try {
            UIManager.setLookAndFeel(
                "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel"
            );
        } catch (Exception exc) {
            // ignore error
        }
    }
    
    public static void main(String[] args) 
    {
        Calculator.setLookAndFeel();
        Calculator cl = new Calculator();
        cl.listener();
    }
    /**
     * 事件监听器，一旦按下按钮就要根据操作历史进行相应的反应
     */
    public void listener()
    {
        Listener l=new Listener(this);
        for(int i=0;i<buttons.length;i++)
        {
            for(int j=0;j<buttons[0].length;j++)
            {
                button[i][j].addActionListener(l);
            }
        }
    }
}

效果

GUI

事件监听器源码

有了按钮后下一步就是要想办法实现按钮功能，我的思路在上面流程图里给过了，不再累赘，直接看如何利用代码实现：

/**
 * @author Hephaest
 * @since  2018/04/19
 * JDK 1.6
 */
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.JButton;
import javax.swing.JTextField;
/**
 * Listener 类
 * 用来将按钮输入的结果通过链表的方式一个字一个字存储在字符串里，然后调用另一类计算整个字符串，返回一个值
 */
public class Listener implements ActionListener
{
    private Calculator cl;
    private ArrayList<String> list=new ArrayList<String>();
    private ArrayList<String> his=new ArrayList<String>();//这个链表用来添加每一次得到的最终的结果
    private ArrayList<String> arr = new ArrayList<String>();//把his里的一整串字符分割成单个字符，再连接
    private String[] arrayStr = new String[] {};//储存单次的历史记录
    private String out="";
    private String output="";
    
    public Listener(Calculator cl)
    {
        this.cl=cl;
    }
    
    public void actionPerformed(ActionEvent event)
    {
        JButton button = (JButton) event.getSource();
        /**
         * 如果点“=”，计算整个表达式的结果，如果是错误表达式，在文本框输入“Input Error!”
         */
        if(button.getText().equals("="))
        {
            try
            {    
                Function f = new Function();
                double result=f.compute(out);
                cl.text.setText(Double.toString(result));
            }catch(Exception e)
            {
                cl.text.setText("Input Error!");
            }
            
        }
        /**
         * 如果点击"×"，先把它转换为"*"
         */
        else if(button.getText().equals("×"))
        {
            if(list.isEmpty())
            {
                arr.add("*");
                output+="*";
                out=output;
                cl.text.setText(output);
            }
            else
            {
                list.add("*");
                output+="*";
                out=output;
                cl.text.setText(output);
            }
        }
        /**
         * 如果点击"÷"，把它转换为"/"
         */
        else if(button.getText().equals("÷"))
        {
            if(list.isEmpty())
            {
                arr.add("/");
                output+="/";
                out=output;
                cl.text.setText(output);
            }
            else
            {
                list.add("/");
                output+="/";
                out=output;
                cl.text.setText(output);
            }
        }
        /**
         * 如果点击"DEL"，删除表达式里最后一个字符，每点一次删一个
         */
        else if(button.getText().equals("DEL"))
        {
            if(list.isEmpty())
            {
                arr.remove(arr.size()-1);
                 output="";
                 for(int i=0;i<arr.size();i++)
                  {
                     output+=arr.get(i);
                  }
                 out=output;
                 cl.text.setText(output);
            }
            else
            {
                 list.remove(list.size()-1);
                 String output="";
                 for(int i=0;i<list.size();i++)
                  {
                     output+=list.get(i);
                  }
                 out=output;
                 cl.text.setText(output);
            }
        }
        /**
         * 如果点击"AC"，删除list链表，再删除之前先把表达式保留到his的链表里
         */
        else if(button.getText().equals("AC"))
        {
            his.add(out);
            list.clear();
            output="";
             cl.text.setText(output);
        }
        /**
         * 如果点击"Replay"，在文本框里显示上一条表达式
         */
        else if(button.getText().equals("Replay"))
        {
            output=his.get(his.size()-1);
            cl.text.setText(output);
            arr.clear();
            //把上一条表达式分割成单个字符的字符数组
            char[] a=output.toCharArray();
            for(int i=0;i<a.length;i++)
            {
                arr.add(String.valueOf(a[i]));
            }
            his.remove(his.size()-1);
        }
        /**
         * 其余按钮可以直接加入表达式
         */
        else
        {
            if(list.isEmpty())
            {
                arr.add(button.getText());
                output+=button.getText();
                out=output;
                cl.text.setText(output);
            }
            else
            {
                list.add(button.getText());
                output+=button.getText();
                out=output;
                cl.text.setText(output);
            }
        }
    }
}

计算器表达式算法

关于如何分析整个表达式并计算出正确值，小编实践了一下，还是后缀表达式比较方便，不用考虑括号这种优先级问题。对于理论算法不再这累赘了，小编在查阅资料的时候发现算法不管用栈还是正则等等，似乎只处理操作符是0～9的数，这是很不可取的。什么意思呢？就是像10/5这样的算数是没办法解决的，只能解决像5/5这样的。所以小编先将中缀表达式转化成后缀并标记多位数的操作符，然后在处理后缀表达式。

/**
 * @author Hephaest
 * @since  2018/07/13
 * JDK 1.6
 */
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
public class function {
    private String[] str=new String[10];
    private int begin;
    public function()
    {
        
    }
    /**
     * 中缀表达式转换成后缀表达式
     * @param exp 在计算器上显示的文本 中缀表达式
     * @return 正确的计算结果
     */
    public double compute(String exp) 
    {
        char[] ch=exp.toCharArray();
        Stack <Character> stack= new Stack<>();
        String convertToPostfix=new String();
        int size=ch.length;
        begin=0;
        for (int i = 0; i < size; i++) {
          //遇到左括号直接入栈
          if(ch[i]=='(') 
          {
              stack.push(ch[i]);
          }
          //遇到右括号出栈（追加到后缀表达式），直到出栈的元素为左括号或为0
          else if(ch[i]==')')
          {
              char popValue=stack.pop();
              do 
              {
                  convertToPostfix=convertToPostfix.concat(String.valueOf(popValue));
                  popValue=stack.pop();
              }while(!stack.isEmpty()&&popValue!='(');
          }
          /*
           * 遇到运算符需要判断：
           * 1.是否为空栈，是的话直接入栈
           * 2.即将入栈的运算符是否比栈顶元素优先级高
           *     是，直接入栈
           *    否，栈顶元素出栈（追加到后缀表达式），当前运算符入栈
           */
          else if(checkOperator(ch[i]))
          {
              if(stack.isEmpty())
              {
                  stack.push(ch[i]);
              }
              else
              {
                  char popValue=stack.pop();
                  while(checkPriority(popValue,ch[i]))
                  {
                      convertToPostfix=convertToPostfix.concat(String.valueOf(popValue));
                      if(stack.isEmpty())
                      {
                          break;
                      }
                      popValue=stack.pop();
                  }
                  if(checkPriority(popValue,ch[i])==false)
                  {
                      stack.push(popValue);
                  }
                  stack.push(ch[i]);
              }
          }
          /*
           * 单个数字直接追加到后缀表达式
           * 含有不止一个数字的操作符需要做记录：
           *     1.计算该操作符的起始位置和终止位置
           *     2.把数字传到字符串数组里（全局变量，下一步需要用到）
           */
          else if(checkDigital(ch[i]))
          {
              if(i+1<size&&i-1>=0)
              {
                  if(checkDigital(ch[i-1])&&!checkDigital(ch[i+1]))
                  {
                      int end=i;
                      int j=end;
                      while(checkDigital(ch[j]))
                      {
                          j--;
                      }
                      j++;
                      List<String> elements = new LinkedList<>();
                      do
                      {
                          elements.add(String.valueOf(ch[j]));
                          j++;
                      }while(j<=end);
                      str[begin]=String.join("", elements);
                      System.out.println(str[begin]);
                      begin++; 
                  }
                  
              }
              convertToPostfix=convertToPostfix.concat(String.valueOf(ch[i]));
          }
         }
        //第一遍结束后把栈中剩下的操作符依次出栈（追加到后缀表达式）
        while(!stack.isEmpty())
        {
            char popValue=stack.pop();
            convertToPostfix=convertToPostfix.concat(String.valueOf(popValue));
        }
        System.out.println(convertToPostfix);
        return computeResult(convertToPostfix);
    }
    /**
     * 计算后缀表达式
     * @param convertToPostfix 后缀表达式的字符串
     * @return 计算结果
     */
    public double computeResult(String convertToPostfix)
    {
        int[] index=new int[10];
        /*
         * 判断是否有多位数的操作符，有的话找到在后缀表达式的初始位置
         * 如果没有的话就不会执行
         */
        for(int i=0;i<begin;i++)
        {
            index[i]=convertToPostfix.indexOf(str[i]);
            System.out.println(index[i]);
        }
        char[] ch=convertToPostfix.toCharArray();
        Stack <Double> stack=new Stack<>();
        double result=0;
        for (int i = 0; i < ch.length; i++) {
            //如果是运算符，pop出栈顶的两个元素，记住先进后出
            if(checkOperator(ch[i]))
            {
                double num2=stack.pop();
                System.out.println("num2"+num2);
                System.out.print("\n");
                double num1=stack.pop();
                System.out.println("num1"+num1);
                System.out.print("\n");
                switch(ch[i])
                {
                    case '*':
                        result=num2*num1;
                        break;
                    case '/':
                        result=num1/num2;
                        break;
                    case '+':
                        result=num1+num2;
                        break;
                    case '-':
                        result=num1-num2;
                        break;
                }
                System.out.println(result);
                stack.push(result);
            }
            /*
             * 对于多位操作符，需要把单个字符连接起来然后作为一个双精度数放入栈中
             * 一位数的操作符直接放入栈即可，注意从字符变成数字时要减去48(0的字符型数据)
             */
            else
            {
                int stop=0;
                for(int j=0;j<begin;j++)
                {
                    if(i==index[j])
                    {
                        int start=i;
                        List<String> elements = new LinkedList<>();
                        do
                        {
                            elements.add(String.valueOf(ch[i]));
                            i++;
                        }while(i<str[j].length()+start);
                        i--;
                        String test=String.join("", elements);
                        stack.push(Double.valueOf(test));
                        stop=1;
                        break;
                    }
                }
                if(stop==0)
                {
                    stack.push((double)ch[i]-48);
                }
            }
        }
        System.out.print("\n");
        System.out.print(result);
        return result;
    }
    /**
     * 判断是否是运算符
     * @param c 当前字符
     * @return 布尔型结果
     */
    public boolean checkOperator(char c)
    {
        int result;
        switch(c)
        {
            case '+':
            case '-':
            case '*':
            case '/':
                result=1;
                break;
            default:
                result=0;
        }
        if(result==1)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    /**
     * 判断是否是数字
     * @param c 当前字符
     * @return 布尔型结果
     */
    public boolean checkDigital(char c)
    {
        int num=c;
        num-=48;
        if(num>=0&&num<=9)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    /**
     * 判断即将入栈的优先级是否更高
     * @param popOne 栈顶元素
     * @param checkOne 即将入栈元素
     * @return 布尔型结果
     */
    public boolean checkPriority(char popOne,char checkOne)
    {
        if((popOne=='*'||popOne=='/')&&(checkOne=='+'||checkOne=='-'))
        {
            return true;
        }
        else if(popOne==checkOne)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

小结

  • 凡事靠自己，多研究多思考
  • 算法比语言更重要
  • Github 源码
weixin_34054866
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java员工管理系统，ArrayList存储
09-17
还有数组班，数据库版，如有需要加关注，给你讲解。
简单计算器实现
qq_45138815的博客
04-05 681
实现一个简单的计算器，前面是一个文本框（操作数1），后面是标签（操作符），再后面是一个文本框（操作数2），然后是一个"="按钮（JButton），最后是一个文本框（结果） （1）实现按钮ActionEvent事件的处理，点击等号获取计算结果，并显示在最后一个文本框； （2）实现第二个文本框的ActionEvent事件处理，在第二个文本框按回车，直接获得计算结果，并显示在最后一个文本框。 （3）实现...
ArrayList()怎么用
fengyehegui的专栏
11-02 294
高手们，帮帮忙！告诉我一些ArrayList()的用法，还有是用Arraylist()创建一个对象，保存十个学生的基本信息怎么做？
ArrayList 学生管理系统
Zc_orange的博客
10-16 364
ArrayList 学生管理系统 一、ArrayList创建变量的步骤 1.导入包 import java.util.*; 2.创建引用类型的变量 数据类型<集合存储的数据类型> 变量名 = new 数据类型<集合存储的数据类型>(); 集合存储的数据类型：要将数据存储到集合的容器中。创建集合引用变量的时候，必须要指定好存储的类型是什么。 3.变量名.方法即可调用 注意尖括...
java实现Arraylist
LZL_YLP的博客
03-27 173
package myDataStructures; //import javax.swing.text.html.HTMLDocument; import java.util.Arrays; import java.util.Iterator; import java.util.Random; //import java.util.TreeMap; ...
基于Java+Swing实现计算器
01-08
在本文中，我们将深入探讨如何使用Java编程语言和Swing GUI库来实现一个功能丰富的计算器，包括基础的计算功能以及保存计算过程的能力。这个项目旨在提高开发者对Java面向对象编程的理解，以及对Swing组件的运用技巧...
Java简单计算器和记事本
04-05
总的来说，"Java简单计算器和记事本"项目涵盖了Java GUI编程的基础知识，包括组件使用、事件处理、文件操作、布局管理以及文本处理等，这些都是Java桌面应用开发的核心技能。通过学习和实践这样的项目，开发者可以...
Java-calculator.zip_calculator gui
09-22
在Java中创建GUI计算器涉及到多个关键知识点： 1. **Java Swing或JavaFX**: Java提供了两种主要的GUI库，Swing和JavaFX。由于年代较早，Swing更常见于旧项目，而JavaFX则提供更现代、丰富的用户界面组件。根据项目...
Java用栈实现的计算器
12-01
本项目是利用栈来实现一个简单的计算器，不支持括号表达式的计算，其用户界面是通过Java Swing库构建的。下面将详细介绍这个计算器的实现原理以及涉及到的相关知识点。 1. **栈的基本概念**： 栈是一种线性数据...
Java_Caculator.rar_Java科学计算器_java计算器_科学计算器_计算器java
09-21
1. **GUI设计**：Java提供了多种图形用户界面（GUI）工具包，如Java Swing和JavaFX，用于创建计算器的外观。开发者可能使用JFrame作为主窗口，JButton表示按键，JLabel显示计算结果。布局管理器如GridLayout、...
【Swing】 事件处理+actionlistener
lzm18064126848的专栏
11-29 1027
Swing是目前Java中不可缺少的窗口工具组，是用户建立图形化用户界面（GUI）程序的强大工具。Java Swing组件自动产生各种事件来响应用户行为。如当用户点击按钮或选择菜单项目时，Swing组件会产生一个ActionEvent。Swing组件会产生许多事件，如ActionEvents,ChangeEvents,ItemEvents等，来响应用户的鼠标点击行为，列表框中值的改变，计时器的开始
每天一个脱发小技巧 | Java 使用二维向量创建GUI表格
PsionicFox的博客
06-05 392
本文介绍了如何利用java自带的JFrame框架，完成一个可视化GUI表格 首先，我们来创建一个JFrame面板 import javax.swing.JFrame; public class GUItable { public static void main(String[] args) { JFrame frame = new JFrame("GUITable");//新建一个名字为GUITable的窗口框架 frame.setBounds(300,0,1000,500);//设置窗口的左
java组件及事件处理（12）--ActionListener监听做计算器
m0_47385081的博客
03-01 927
java组件及事件处理（12）–ActionListener监听做计算器 一般文本框，按钮，菜单项，单选按钮会使用ActionListener 加入监听器 分三步 （1） implements ActionListener （2）负责加监听器的 地方 addActionListener(this) （3）新的一个负责监听的方法里面写时间处理程序 下面的例子通过监听器实现— 在文本框中输入数字，回车会将文本框中的内容进行加减乘除的计算，得到的结果放进结果文本框中 import java.awt.Color;
Java中ArrayList详解与练习
神经大条蕾弟的博客
06-09 1468
本人学生党一枚。Java学习过程，写这个博客纯属当复习，有什么错误的地方请大家指出来在评论里指点指点我。谢谢ArrayList概念:ArrayList是升级版的数组,我们都知道数组的缺陷是要在使用之前要把范围定死,换句话说数组不能动态的改变长度。而ArrayList可以做到。 ArrayList 是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractLi
JAVA中JButton常用设置
MartinDong
09-09 2203
1、 对JButton大小的设置      ——因为JButen是属于小器件类型的，所以一般的setSize不能对其惊醒大小的设置，所以一般我们用      button.setPreferredSize(new Dimension(30,30));      //（30，30） 是你要设置按钮的大小 2、 对JButton透明的设置      ——按钮设置为透明，这样就不会挡着后面的背
利用Swing包中实现简单学生信息GUI
最新发布
06-01
好的，我可以为你提供一个简单的Swing GUI程序，用来存储和显示学生的信息。下面是代码示例： ```java import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值