• 【JAVA】-- 简易超市管理系统窗口（三）（实现思路+每步代码）

    前面完成了界面的基本布局，接下来实现把输入框的文字保存到文件中，和进货、清空的功能。

    进货开销、货款余额、进货日期为自动计算后输入。

    一、创建保存数据的文件

    创建三个文件，分别用于保存进货销货的数据文件、商品名称和数量文件和剩余总资金的文件。

    这个三个文件充当着数据库的作用，以便保存数据和以后的使用这些数据。

    Zeng类增加

    实例化File类对象，如果文件不存在则创建文件。（一般情况第一次使用都不存在）

        File file,file1,file2;//三个文件分别为：进货数据文件、商品记录文件、总余额文件

    构造方法增加

    1.  /**创建新文件，相当于数据库，用来保存新增物品的信息*/
    2.         file = new File("E:\\大二\\下\\JAVA\\JAVA课程\\专题训练\\超市管理系统\\sava_date.txt");
    3.         if(!file.exists()){//判断文件是否为空，首次运行文件为空
    4.             try {
    5.                 file.createNewFile();
    6.             }catch (Exception e){
    7.                 e.printStackTrace();
    8.             }
    9.         }
    10.         file1 = new File("E:\\大二\\下\\JAVA\\JAVA课程\\专题训练\\超市管理系统\\sava_member.txt");
    11.         if(!file1.exists()){
    12.             try {
    13.                 file1.createNewFile();
    14.             }catch (Exception e){
    15.                 e.printStackTrace();
    16.             }
    17.         }
    18.         file2 = new File("E:\\大二\\下\\JAVA\\JAVA课程\\专题训练\\超市管理系统\\sava_money.txt");
    19.         if(!file2.exists()){
    20.             try {
    21.                 file2.createNewFile();
    22.             }catch (Exception e){
    23.                 e.printStackTrace();
    24.             }
    25.         }

    第一个文件：保存进货数据

     第二个文件：保存商品信息文件

     第三个文件：保存剩余总资金文件

     

    二、增加“进货”按钮点击事件

    增加点击事件，判断进货名称、厂家、价格、数量、操作人不能为空，如果为空则提醒并返回。

    Zeng类增加

    构造方法增加点击事件

    为button1增加点击事件，获取到输入框的内容判断是否为空，null和queals（“”）都表示为空，但是null表示无内存空间，后者为无内容。

    1.         button1.addActionListener(new ActionListener() {
    2.             @Override
    3.             public void actionPerformed(ActionEvent e) {
    4.                 if(getField1().getText() == null || getField1().getText().equals("")){
    5.                     JOptionPane.showMessageDialog(null,"商品名称不可为空");
    6.                     return;
    7.                 }
    8.                 if(getField2().getText() == null || getField2().getText().equals("")){
    9.                     JOptionPane.showMessageDialog(null,"商品厂家不可为空");
    10.                     return;
    11.                 }
    12.                 if(getField3().getText()==null||getField3().getText().equals("")){
    13.                     JOptionPane.showMessageDialog(null,
    14.                             "进货价格不可为空");
    15.                     return; //该处内容不能为空
    16.                 }
    17.                 if(getField4().getText()==null||getField4().getText().equals("")){
    18.                     JOptionPane.showMessageDialog(null,
    19.                             "进货数量不可为空");
    20.                     return; //该处内容不能为空
    21.                 }
    22.                 if(getField7().getText()==null||getField7().getText().equals("")){
    23.                     JOptionPane.showMessageDialog(null,
    24.                             "经办人不可为空");
    25.                     return;
    26.                 }
    27.  
    28.  
    29.             }
    30.         });

    三、“进货开销”：根据进货价格与数量自动输入

    先从保存资金的文件中读取余额资金，没有内容就直接赋值30000，然后在有进货价格和数量的条件下，获取进货价格与数量，两者相乘就是进货的总金额，如果余额足够就自动输入到输入框。

    Zeng类增加

    构造方法增加

    在进货时，需要判断自己的资金是否够进货条件，需要先拿到自己的资金。

    使用高级流读取文件内容，好处是可以每次读取文件一行数据，也就是一条数据；

    读取到文件内容后，将字符串类型转换为Double类型，注意这里没有用循环而是条件，因为文件只有一行数据，

    如果没有读取到内容，则直接给一个默认值30000，就当是贷款了先欠着（O(∩_∩)O）。

    1.  String expenseStr = null;//进货开销
    2.                 try {
    3.                     FileReader fr = new FileReader(file2);//读取资金文件
    4.                     BufferedReader br = new BufferedReader(fr);//高级流，可以每次读取TXT文件的一行，每次读取一条数据
    5.                     String str;
    6.                     double totalMoney = 0;//剩余可用资金
    7.                     if((str = br.readLine()) != null){//读取文件内容
    8.                         totalMoney = Double.parseDouble(str);
    9.                     }else{
    10.                         totalMoney = 30000;//没有读取到内容，就直接赋值30000
    11.                     }
    12.

    接下来获取商品单价与数量的输入框内容，不为空时进行下一步；

    拿到输入框的内容是字符串类型，需要先转换为Double类型；

    商品数量与单价相乘就是这次的花费总金额，需要判断余额资金是否够本次花费，

    如果够，则在输入框上自动输入，

    如果不够，则提醒并返回。

    1.  if(getField3().getText()!=null&&getField4().getText()!=null){
    2.                         String priceStr = getField3().getText();
    3.                         double price = Double.parseDouble(priceStr);
    4.                         String memberStr = getField4().getText();
    5.                         double member = Double.parseDouble(memberStr);
    6.                         double result = price*member;//本次共花费金额
    7.                         if(result > totalMoney){//进货金额不能大于剩余的金额
    8.                             getField4().setText("");
    9.                             JOptionPane.showMessageDialog(null,"余额不足");
    10.                             return;
    11.                         }else{//余额足够就设置进货开销
    12.                             getField5().setText(String.format("%.2f",result));//余额保留三位小数
    13.                         }
    14.                     }
    15.                 }catch (Exception e1){
    16.                         e1.printStackTrace();
    17.                 }

    四、计算剩余总资金保存到文件并输入到货款余额

    先计算进货后剩余的总资金，如果资金为负数则提示，为正数则自动输入到货款余额中并刷新保存到文件。

    Zeng类增加

    构造方法中的进货开销异常中增加

    计算得到本次进货后剩余的总资金；

    如果还有剩余资金，则输入到货款余额输入框中，并保存到文件中，

    如果没有剩余，则表示本次进货资金准备不充足，不能进货，提示并返回。

    1. expenseStr = getField5().getText();//获取到进货开销后，计算总资金余额，并保存文件
    2.                     double expense = Double.parseDouble(expenseStr);//本次花费
    3.                     double surplus = totalMoney - expense;//本次进货后剩余资金
    4.                     if(surplus >=0){//如果本次还剩余了钱，输入到输入框
    5.                         getField6().setText(String.format("%.2f",surplus));
    6.                         try {//将剩余金额保存到文件中
    7.                             FileWriter fw = new FileWriter(file2);
    8.                             BufferedWriter bw = new BufferedWriter(fw);
    9.                             bw.write(String.valueOf(surplus));//valueOf是将其他类型转换为字符串类型
    10.                             bw.close();
    11.                             fw.close();
    12.                         }catch (Exception e1){
    13.                             e1.printStackTrace();
    14.                         }
    15.                     }
    16.                     else{//如果没有剩余资金,提示
    17.                         JOptionPane.showMessageDialog(null,"货款余额不可为负数");
    18.                         return;
    19.                     }
    20.                     br.close();
    21.                     fr.close();
    22.                 }catch (Exception e1){
    23.                         e1.printStackTrace();
    24.                 }

    五、设置进货日期

    Zeng类增加

    构造方法中增加

    1. SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");//设置时间格式
    2.                 Date date = new Date();//获取当前时间
    3.                 String dateNow = format.format(date);//按照格式设置时间
    4.                 getField8().setText(dateNow);//写入到输入框

    六、进货记录写入文件

    首先读取文件：用集合把以前的文件记录保存，先在集合中添加最新的记录；

    然后写入文件：用迭代器把集合中的记录取出，把文件清空，再全部写入。

    Zeng类增加

    构造方法增加

    先用集合保存原文件的所有内容。

    1.  try {//保存货物进销记录
    2.                     FileReader fr = new FileReader(file);
    3.                     BufferedReader br = new BufferedReader(fr);
    4.                     List<String> list = new ArrayList<String>();//存放进销信息的集合
    5.                     String str = null;
    6.                     while ((str = br.readLine()) != null){
    7.                         list.add(str);
    8.                     }

     然后再把新信息字符串的格式拼接好增加到集合中

    1.  int line = list.size();//用于获取集合中元素的数量
    2.                     String nameStr=",货物名称:"+getField1().getText();
    3.                     String makerStr=",货物厂家:"+getField2().getText();
    4.                     String priceStr=",货物价格:"+getField3().getText();
    5.                     String memberStr=",货物数量:"+getField4().getText();
    6.                     expenseStr=",货物开销:"+expenseStr;
    7.                     String surplusStr=",货款余额:"+getField6().getText();
    8.                     String operatorStr=",经办人:"+getField7().getText();
    9.                     String dateStr=",进货日期:"+getField8().getText();
    10.                     String finStr="单号："+getField8().getText()+"#"+ i++
    11.                             +nameStr+makerStr+priceStr+memberStr+expenseStr+
    12.                             surplusStr+operatorStr+dateStr;
    13.                     list.add(line,finStr);//将新信息添加到集合

    最后把文件的原内容都清空，把当前新的集合用迭代器写入文件。

    1.  FileWriter fw = new FileWriter(file);
    2.                     BufferedWriter bw = new BufferedWriter(fw);
    3.                     bw.write("");//将原来的内容清空，重新写入
    4.                     FileWriter fw1 = new FileWriter(file,true);//true表示每次写入的内容可以叠加不会被覆盖
    5.                     BufferedWriter bw1 = new BufferedWriter(fw1);
    6.                     Iterator<String> it = list.iterator();//用迭代器获取集合中的元素
    7.                     while (it.hasNext()){
    8.                         String value = it.next();
    9.                         bw1.write(value);
    10.                         bw1.newLine();//换行
    11.                     }
    12.                     bw.close();
    13.                     fw.close();
    14.                     bw1.close();
    15.                     fw1.close();
    16.                     br.close();
    17.                     fr.close();
    18.                 }catch(Exception e1){
    19.                     e1.printStackTrace();
    20.                 }

    七、商品名称、商品数量写入文件

    先读取文件，存入集合，对比商品，如果是新商品，则添加到集合；

    写入文件，先清空原文件，再将集合的所有元素都写入文件。

    Zeng类增加

    读取文件内容，将原文件所有内容放入集合；

    再判断原文件有无新商品的情况，生成新的记录放入集合；

    最后将集合的所有元素保存进文件中。

    构造方法增加

    如果文件的内容为空，则写入无商品。

    1. try{
    2.           if(file1.length()==0){ //file1表示商品剩余数量文件
    3.             try{
    4.               FileWriter fw=new FileWriter(file1);
    5.               BufferedWriter bw=new BufferedWriter(fw);
    6.               bw.write("商品名称:无商品数量:0;\n");//初始内容
    7.               bw.close();
    8.               fw.close();
    9.             }catch(Exception e1){
    10.               e1.printStackTrace();
    11.             }
    12.           }

    读取文件内容，将文件所有内容存入集合

    1. FileReader fr=new FileReader(file1);
    2.           BufferedReader br=new BufferedReader(fr);
    3.           String str;
    4.           List<String> list=new ArrayList<String>();
    5.           while((str=br.readLine())!=null){
    6.             list.add(str);//将原有内容存入集合
    7.           }

    再次读取文件，如果文件不为空，则获取的商品的名称，“商品名称”出现的位置一般是0下标，从再+5下标开始，+5是“商品名称：”这5个字符，到“商品数量”出现的位置结束；

    判断文件第一行的商品名称是否与本次输入框中的商品名称相同，（为什么和第一行内容比较，后面有方法将多余的相同商品名称的数量合并），

    不相同则生成一条新的记录，将记录添加到集合。

    1.  FileReader fr1=new FileReader(file1);
    2.           BufferedReader br1=new BufferedReader(fr1);
    3.           String str1;//保存文件中上一次进货的商品名称和数量
    4.           int line=list.size();//获取记录条目数量
    5.           if((str1=br1.readLine())!=null){
    6.             int indexCommodity=str1.indexOf("商品名称");
    7.             int indexMember=str1.indexOf("商品数量");
    8.             String nameCommodity=str1.substring(
    9.                 indexCommodity+5, indexMember);//获取商品名称
    10.             if(!nameCommodity.equals(getField1().getText())){
    11.               String result="商品名称:"+getField1().getText()+
    12.                   "商品数量:"+getField4().getText()+";";
    13.               //如果商品是原来没有的，则生成一条新的记录
    14.               list.add(line, result);//将新的记录加入集合
    15.             }
    16.           }

    将原文件清空，将新集合写入到文件中。

    1.  FileWriter fw=new FileWriter(file1);
    2.           BufferedWriter bw=new BufferedWriter(fw);
    3.           bw.write("");
    4.           FileWriter fw1=new FileWriter(file1, true);
    5.           BufferedWriter bw1=new BufferedWriter(fw1);
    6.           Iterator<String> it=list.iterator();
    7.           while(it.hasNext()){
    8.             String value=it.next();
    9.             bw1.write(value);//将新的商品剩余数量记录写入文件
    10.             bw1.newLine();
    11.           }
    12.           bw.close();
    13.           fw.close();
    14.           bw1.close();
    15.           fw1.close();
    16.           br1.close();
    17.           fr1.close();
    18.           br.close();
    19.           fr.close();
    20.         }catch(Exception e1){
    21.           e1.printStackTrace();
    22.         }

    八、同一商品数量合并

    将同一商品名称但是数量不同的记录合并，将原来多条记录中序号最小的记录修改为合并后的数量，但是将其余的记录中的数量修改为0。

    Zeng类增加

    构造方法增加

    还是先从文件中拿到所有的内容添加到集合中。

    1.         try{//合并商品数量
    2.           FileReader fr=new FileReader(file1);
    3.           BufferedReader br=new BufferedReader(fr);
    4.           List<String> list=new ArrayList<String>();
    5.           String str;
    6.           while((str=br.readLine())!=null){
    7.             list.add(str);//现将原始数据提取并保存
    8.           }

    使用双循环拿到前一个和后一个商品的名称，iValue是前一个商品，jValue是下一个商品。

    1.  int line=list.size();//获取数据数量
    2.           for(int i=0;i<=line-2;i++){
    3.             for(int j=i+1;j<=line-1;j++){
    4.               String iStr=list.get(i);
    5.               int index1=iStr.indexOf("商品数量");
    6.               String iValue=iStr.substring(5, index1);
    7.               String jStr=list.get(j);
    8.               int index2=jStr.indexOf("商品数量");
    9.               String jValue=jStr.substring(5, index2);

    然后判断前后商品名称是否相同，是同一商品则拿到前后商品的商品数量。

    1.  if(iValue.equals(jValue)){
    2.                 int start1=iStr.indexOf("商品数量");
    3.                 int end1=iStr.indexOf(";");
    4.                 String value1=iStr.substring(start1+5, end1);
    5.                 int iMember=Integer.parseInt(value1);
    6.                 int start2=jStr.indexOf("商品数量");
    7.                 int end2=jStr.indexOf(";");
    8.                 String value2=jStr.substring(start2+5, end2);
    9.                 int jMember=Integer.parseInt(value2);

    将两商品数量相加，然后将前一个商品（即序号小的）设置为合并后的数量，

    后一商品设置为0，后面方法中删除。

    1.  int totalMember=iMember+jMember;
    2.                 list.set(i, "商品名称:"+iValue+"商品数量:"
    3.                     +String.valueOf(totalMember)+";");
    4.                 list.set(j, "商品名称:"+iValue+"商品数量:"
    5.                     +String.valueOf(0)+";");

    最后文件清空，将新集合写入文件。

    1.  FileWriter fw=new FileWriter(file1);
    2.                 BufferedWriter bw=new BufferedWriter(fw);
    3.                 bw.write("");
    4.                 FileWriter fw1=new FileWriter(file1, true);
    5.                 BufferedWriter bw1=new BufferedWriter(fw1);
    6.                 Iterator<String> it=list.iterator();
    7.                 while(it.hasNext()){
    8.                   String value=it.next();
    9.                   bw1.write(value);
    10.                   bw1.newLine();
    11.                 }
    12.                 bw.close();
    13.                 fw.close();
    14.                 bw1.close();
    15.                 fw1.close();
    16.                 br.close();
    17.                 fr.close();
    18.               }
    19.             }
    20.           }
    21.         }catch(Exception e1){
    22.           e1.printStackTrace();
    23.         }

    九、货款余额写入文件

    Zeng类增加

    构造方法增加

    1. try{
    2.           FileWriter fw=new FileWriter(file2);
    3.           BufferedWriter bw=new BufferedWriter(fw);
    4.           bw.write(getField6().getText());//货款余额写入文件
    5.           bw.close();
    6.           fw.close();
    7.         }catch(Exception e1){
    8.           e1.printStackTrace();
    9.         }

    十、删除保存商品数量文件中的废弃记录

    将前面合并后商品数量为0的废弃记录删除，先用集合将文件里的内容保存，然后遍历集合，找到商品数量为0的商品并在集合中移除，最后将文件清空，将修改后的集合保存进文件。

    Zeng类增加

    构造方法增加

    还是获取原文件全部内容，添加到集合中。

    1.         try{
    2.           FileReader fr=new FileReader(file1);
    3.           BufferedReader br=new BufferedReader(fr);
    4.           List<String> list=new ArrayList<String>();
    5.           String str;
    6.           while((str=br.readLine())!=null){
    7.             list.add(str);
    8.           }//到此处的作用是保存原有文件的内容至一个集合

     将集合中的元素取出，依次判断数量是否为0

    1.  String str1;
    2.           int i=1;
    3.           int line=list.size();//获取集合行数
    4.           while((str1=list.get(i))!=null){
    5.             int start=str1.indexOf("商品数量");
    6.             int end=str1.indexOf(";");
    7.             String value=str1.substring(start+5, end);
    8. /**
    9.   截取商品数量的值
    10. */
    11.             if(value.equals("0")){
    12.               list.remove(i);
    13.               line-=1;
    14.             }//寻找file1文件中数量为0的废弃记录，并删除
    15.             if(i<=line-2){
    16.               i++;//如果没有到达最后一行，就顺序遍历
    17.             }else{
    18.               break;
    19.             }
    20.           }

    最后将新集合写入文件。

    1.   FileWriter fw=new FileWriter(file1);
    2.           BufferedWriter bw=new BufferedWriter(fw);
    3.           bw.write("");
    4.           FileWriter fw1=new FileWriter(file1, true);
    5.           BufferedWriter bw1=new BufferedWriter(fw1);
    6.           Iterator<String> it=list.iterator();
    7.           while(it.hasNext()){
    8.             String value=it.next();
    9.             bw1.write(value);
    10.             bw1.newLine();
    11.           }
    12.           bw.close();
    13.           fw.close();
    14.           bw1.close();
    15.           fw1.close();
    16.           br.close();
    17.           fr.close();
    18.         }catch(Exception e1){
    19.           e1.printStackTrace();
    20.         }

    十一、“清空”按钮增加点击事件

    Zeng类增加

    构造方法增加

    1. button2.addActionListener(new ActionListener() {
    2.             @Override
    3.             public void actionPerformed(ActionEvent e) {
    4.                 getField1().setText("");
    5.                 getField2().setText("");
    6.                 getField3().setText("");
    7.                 getField4().setText("");
    8.                 getField5().setText("");
    9.                 getField6().setText("");
    10.                 getField7().setText("");
    11.                 getField8().setText("");
    12.             }
    13.         });

    至此，“增加内容”功能已经完成，还有三个功能待完成。

  • 相关阅读:
    不同MySQL服务的表以及库的数据迁移（/备份）
    Redis设计与实现笔记 - 数据结构篇
    Linux编程——经典链表list_head
    CentOS7.x部署GreenPlum6.x
    杰理之蓝牙连接设备的 API【篇】
    10个基于.Net开发的Windows开源软件项目
    vue脚手架vue-cli的卸载与安装方式
    CentOS（2）——rpm和yum区别与联系
    第33讲：MySQL存储引擎的介绍和基本应用
    常见的请求头，怎么用?
  • 原文地址：https://blog.csdn.net/Tir_zhang/article/details/125416313