十七、IO流——综合练习

综合练习目录

一、制造假数据
- 1.1自己写代码
- 1.2 利用糊涂包生成假数据
二、随机点名器
- 2.1随机点名器1
- 2.2 随机点名器2
- 2.3 随机点名器3
- 2.4 随机点名器4
- 2.5 随机点名器5
三、登录注册
- 3.1 登录注册1
- 3.2 登录注册2
- 3.3 登录注册3

一、制造假数据

需求：制造假数据也是开发中的一个能力，在各个网上爬取数据，是其中一个方法。

在这里插入图片描述

https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0
男孩子取名
女孩子取名

1.1自己写代码

package Test1;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test1 {
    public static void main(String[] args) throws IOException {
        //0.定义变量记录网址
        String famliyName = "https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0";
        String boyName = "http://www.haoming8.cn/quming/65959.html";
        String girlName = "http://www.haoming8.cn/quming/65978.html";

        //1.爬取数据，把网址上所有的数据拼接成一个字符串
        String famliyNameStr = webCrawler(famliyName);
        String boyNameStr = webCrawler(boyName);
        String girlNameStr = webCrawler(girlName);

        //2.通过正则表达式，把其中符合要求的数据获取出来
        ArrayList<String> familyNameTempList = getData(famliyNameStr, "(.{4})(，|。)", 1);
        ArrayList<String> boyNameTempList = getData(boyNameStr, "(..)(、|。)", 1);
        ArrayList<String> girlNameTempList = getData(girlNameStr, "([\\u4E00-\\u9FA5]{2})(、)", 1);

        //3.处理数据
        //3.1姓
        ArrayList<String> familyNameList = new ArrayList<>();
        for (String str : familyNameTempList) {
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                familyNameList.add(c + "");
            }
        }

        //3.2男生姓名
        ArrayList<String> boyNameList = new ArrayList<>();
        //去重
        for (String str : boyNameTempList) {
            if (!boyNameList.contains(str)) {
                boyNameList.add(str);
            }
        }

        //3.3女生姓名
        ArrayList<String> girlNameList = new ArrayList<>();
        //去重
        for (String str : girlNameTempList) {
            if (!girlNameList.contains(str)) {
                girlNameList.add(str);
            }
        }

        //4.生成数据
        ArrayList<String> list = getInfon(familyNameList, boyNameList, girlNameList, 50, 70);

        //5.写出数据
        BufferedWriter bw = new BufferedWriter(new FileWriter("day30_code/src/Test1/name.txt"));
        for (String str : list) {
            bw.write(str);
            bw.newLine();
        }
        bw.close();

    }

    /*
     * 作用：获取男生和女生的信息
     *
     * 参数1：姓氏集合
     * 参数2：男生名集合
     * 参数3：女生名集合
     * 参数4：男生个数
     * 参数5：女生个数*/
    private static ArrayList<String> getInfon(ArrayList<String> familyNameList,
                                              ArrayList<String> boyNameList,
                                              ArrayList<String> girlNameList,
                                              int boyCount,
                                              int girlCount) {
        //0.生成男生不重复的名字
        HashSet<String> boyhs = new HashSet<>();
        while (true) {
            if (boyhs.size() == boyCount) {
                break;
            }
            //随机
            Collections.shuffle(familyNameList);
            Collections.shuffle(boyNameList);
            boyhs.add(familyNameList.get(0) + boyNameList.get(0));
        }

        //1.生成女生不重复的名字
        HashSet<String> girlhs = new HashSet<>();
        while (true) {
            if (girlhs.size() == girlCount) {
                break;
            }
            //随机
            Collections.shuffle(familyNameList);
            Collections.shuffle(girlNameList);
            girlhs.add(familyNameList.get(0) + girlNameList.get(0));
        }

        //生成最终信息
        ArrayList<String> list = new ArrayList<>();
        Random r = new Random();
        for (String boyName : boyhs) {
            //年龄：18~27
            int age = r.nextInt(10) + 18;
            list.add(boyName + "-男-" + age);
        }

        for (String girlName : girlhs) {
            //18~25
            int age = r.nextInt(7) + 18;
            list.add(girlName + "-女-" + age);
        }

        Collections.shuffle(list);
        return list;
    }

    /*
     * 作用：根据正则表达式获取字符串中的数据
     * 参数一：完整的字符串
     * 参数二：正则表达式
     * 参数三：获取匹配正则表达式中的第几组数据
     *
     * 返回值：真正想要的数据*/
    private static ArrayList<String> getData(String str, String regex, int index) {
        ArrayList<String> list = new ArrayList<>();

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            String group = matcher.group(index);
            list.add(group);
        }
        return list;
    }

    /*
     * 作用：从网络中爬取数据，把数据拼接成字符串返回
     * 形参：网址
     * 返回值：爬取到的所有数据*/
    private static String webCrawler(String net) throws IOException {
        StringBuilder sb = new StringBuilder();

        //创建一个URL对象
        URL url = new URL(net);
        URLConnection conn = url.openConnection();

        InputStreamReader isr = new InputStreamReader(conn.getInputStream());

        int ch;
        while ((ch = isr.read()) != -1) {
            sb.append((char) ch);
        }

        isr.close();
        return sb.toString();
    }
}

1.2 利用糊涂包生成假数据

package Test1;

import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.ReUtil;
import cn.hutool.http.HttpUtil;

import java.io.IOException;
import java.util.*;

public class HuToolTest {
    public static void main(String[] args) throws IOException {
        //0.定义变量记录网址
        String famliyName = "https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0";
        String boyName = "http://www.haoming8.cn/quming/65959.html";
        String girlName = "http://www.haoming8.cn/quming/65978.html";

        //1.请求列表页
        String familyNameStr = HttpUtil.get(famliyName);
        String boyNameStr = HttpUtil.get(boyName);
        String girlNameStr = HttpUtil.get(girlName);

        //2.利用正则表达式获取数据
        List<String> familyNameTempList = ReUtil.findAll("(.{4})(，|。)", familyNameStr, 1);
        List<String> boyNameTempList = ReUtil.findAll("(..)(、|。)", boyNameStr, 1);
        List<String> girlNameTempList = ReUtil.findAll("([\\u4E00-\\u9FA5]{2})(、)", girlNameStr, 1);

        //3.处理数据
        //3.1姓
        ArrayList<String> familyNameList = new ArrayList<>();
        for (String str : familyNameTempList) {
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                familyNameList.add(c + "");
            }
        }

        //3.2男生姓名
        ArrayList<String> boyNameList = new ArrayList<>();
        //去重
        for (String str : boyNameTempList) {
            if (!boyNameList.contains(str)) {
                boyNameList.add(str);
            }
        }

        //3.3女生姓名
        ArrayList<String> girlNameList = new ArrayList<>();
        //去重
        for (String str : girlNameTempList) {
            if (!girlNameList.contains(str)) {
                girlNameList.add(str);
            }
        }

        //4.生成数据
        ArrayList<String> list = getInfon(familyNameList, boyNameList, girlNameList, 50, 70);

        //5.写出数据
        //糊涂包的相对路径，不是相对于当前项目而言，而是相对于class文件而言的
        FileUtil.writeLines(list,"nameOfHuTool.txt", "UTF-8");

    }
    /*
     * 作用：获取男生和女生的信息
     *
     * 参数1：姓氏集合
     * 参数2：男生名集合
     * 参数3：女生名集合
     * 参数4：男生个数
     * 参数5：女生个数*/
    private static ArrayList<String> getInfon(ArrayList<String> familyNameList,
                                              ArrayList<String> boyNameList,
                                              ArrayList<String> girlNameList,
                                              int boyCount,
                                              int girlCount) {
        //0.生成男生不重复的名字
        HashSet<String> boyhs = new HashSet<>();
        while (true) {
            if (boyhs.size() == boyCount) {
                break;
            }
            //随机
            Collections.shuffle(familyNameList);
            Collections.shuffle(boyNameList);
            boyhs.add(familyNameList.get(0) + boyNameList.get(0));
        }

        //1.生成女生不重复的名字
        HashSet<String> girlhs = new HashSet<>();
        while (true) {
            if (girlhs.size() == girlCount) {
                break;
            }
            //随机
            Collections.shuffle(familyNameList);
            Collections.shuffle(girlNameList);
            girlhs.add(familyNameList.get(0) + girlNameList.get(0));
        }

        //生成最终信息
        ArrayList<String> list = new ArrayList<>();
        Random r = new Random();
        for (String boyName : boyhs) {
            //年龄：18~27
            int age = r.nextInt(10) + 18;
            list.add(boyName + "-男-" + age);
        }

        for (String girlName : girlhs) {
            //18~25
            int age = r.nextInt(7) + 18;
            list.add(girlName + "-女-" + age);
        }

        Collections.shuffle(list);
        return list;
    }
}

二、随机点名器

2.1随机点名器1

需求：
有一个文件里面存储了班级同学的信息，每一个信息占一行。
格式为：张三-男-23
要求通过程序实现随机点名器。

在这里插入图片描述

public static void main(String[] args) throws IOException {
        /*需求：
        有一个文件里面存储了班级同学的信息，每一个信息占一行。
        格式为：张三-男-23
        要求通过程序实现随机点名器。*/

        //0.获取数据
        BufferedReader br = new BufferedReader(new FileReader("day30_code/name.txt"));
        ArrayList<String> list = new ArrayList<>();
        String line;
        while ((line = br.readLine()) != null) {
            //1.将数据添加到集合中
            list.add(line);
        }
        //释放资源
        br.close();

        //随机-点10次名
        for (int i = 0; i < 10; i++) {
            Collections.shuffle(list);
            String[] arr = list.get(0).split("-");
            System.out.println("第" + (i + 1) + "次点名： " + arr[0]);
        }
    }

2.2 随机点名器2

需求：
        一个文件里面存储了班级同学的信息，格式为：张三-男-23
        每一个学生信息占一行。
        要求通过程序实现随机点名器。
        70%的概率随机到男生
        30%的概率随机到女生
        随机100万次，统计结果。看生成男生和女生的比例是不是接近于7：3

public static void main(String[] args) throws IOException {
        /*需求：
            一个文件里面存储了班级同学的信息，格式为：张三-男-23
            每一个学生信息占一行。
            要求通过程序实现随机点名器。
            70%的概率随机到男生
            30%的概率随机到女生
            随机100万次，统计结果。看生成男生和女生的比例是不是接近于7：3*/

        //0.获取数据
        BufferedReader br = new BufferedReader(new FileReader("day30_code/name.txt"));

        //1.定义两个集合用来分别存储男生、女生的信息
        ArrayList<String> boyList = new ArrayList<>();
        ArrayList<String> girlList = new ArrayList<>();
        String line;
        while ((line = br.readLine()) != null) {
            String[] arr = line.split("-");
            if (arr[1].equals("男")) {
                boyList.add(line);
            } else {
                girlList.add(line);
            }
        }
        //释放资源
        br.close();

        //定义权重集合
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0);

        //随机
        Random r = new Random();
        //定义变量统计被点到的次数
        int boyCount = 0;
        int girlCount = 0;
        //循环1000000次
        for (int i = 0; i < 1000000; i++) {
            int index = r.nextInt(list.size());
            int weight = list.get(index);
            if (weight == 1) {
                //男
                Collections.shuffle(boyList);
                System.out.println(boyList.get(0));
                boyCount++;
            } else {
                //女
                Collections.shuffle(girlList);
                System.out.println(girlList.get(0));
                girlCount++;
            }
        }

        System.out.println("随机抽取100万次，其中男生被抽到了" + boyCount);
        System.out.println("随机抽取100万次，其中女生被抽到了" + girlCount);
    }

在这里插入图片描述

2.3 随机点名器3

需求：
        一个文件里面存储了班级同学的姓名，每一个姓名占一行。
        要求通过程序实现随机点名器。
        第三次必定是张三同学

      运行效果：
        第一次运行程序：随机同学姓名1
        第二次运行程序：随机同学姓名2
        第三次运行程序：张三
        …

public static void main(String[] args) throws IOException {
        /*需求：
            一个文件里面存储了班级同学的姓名，每一个姓名占一行。
            要求通过程序实现随机点名器。
            第三次必定是张三同学

            运行效果：
            第一次运行程序：随机同学姓名1
            第二次运行程序：随机同学姓名2
            第三次运行程序：张三
                …*/
        //0.读取数据
        BufferedReader br = new BufferedReader(new FileReader("day30_code/name.txt"));
        ArrayList<String> nameList = new ArrayList<>();
        String line;
        while ((line = br.readLine()) != null) {
            nameList.add(line);
        }
        br.close();

        //2.读取当前程序已经运行的次数
        BufferedReader br1 = new BufferedReader(new FileReader("day30_code/count.txt"));
        String countStr = br1.readLine();
        int count = Integer.parseInt(countStr);

        //3.程序没运行一次count+1
        count++;

        //判断
        if (count == 3){
            System.out.println("张三");
        } else {
            //点名
            Collections.shuffle(nameList);
            String[] arr = nameList.get(0).split("-");
            System.out.println(arr[0]);

        }
        System.out.println(count);

        //将count写入文件中
        BufferedWriter bw = new BufferedWriter(new FileWriter("day30_code/count.txt"));
        bw.write(count+"");
        bw.close();
    }

2.4 随机点名器4

需求：
        一个文件里面存储了班级同学的姓名，每一个姓名占一行。
        要求通过程序实现随机点名器。

      运行结果要求：
        被点到的学生不会再被点到。
        但是如果班级中所有的学生都点完了， 需要重新开启第二轮点名。

      核心思想：
           点一个删一个，把删除的备份，全部点完时还原数据。

package Test2;

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;

public class Test5 {
    public static void main(String[] args) throws IOException {
        /*需求：
            一个文件里面存储了班级同学的姓名，每一个姓名占一行。
            要求通过程序实现随机点名器。

          运行结果要求：
            被点到的学生不会再被点到。
            但是如果班级中所有的学生都点完了， 需要重新开启第二轮点名。

          核心思想：
               点一个删一个，把删除的备份，全部点完时还原数据。
               */

        //定义变量，表示初始文件路径
        String src = "day30_code/name.txt";
        //定义变量，表示备份文件，一开始文件为空
        String backups = "day30_code/src/Test2/backups.txt";

        //测试点名121次
        for (int i = 0; i < 121; i++) {
            //获取数据并将其装入集合中
            ArrayList<String> list = readFile(src);

            //判断集合中是否有数据
            if (list.size() == 0) {
                //如果没有数据，表示所有学生已经点完，从backups.txt中还原数据即可
                list = readFile(backups);
                //把所有数据都写到初始文件中
                writeFile(src, list, false);
                //删除备份数据
                new File(backups).delete();
            }

            //点名-点一个删一个
            Collections.shuffle(list);
            String stuInfo = list.remove(0);
            System.out.println("被点名的学生是："+stuInfo);
            //把删除之后的所有学生写到初始文件中
            writeFile(src,list,false);
            writeFile(backups,stuInfo, true);//追加写入
        }

    }

    private static void writeFile(String pathFile, String str, boolean isAppend) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter(pathFile, isAppend));
        bw.write(str);
        bw.newLine();
        bw.close();
    }

    private static void writeFile(String pathFile, ArrayList<String> list, boolean isAppend) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter(pathFile, isAppend));
        for (String str : list) {
            bw.write(str);
            bw.newLine();
        }
        bw.close();
    }

    private static ArrayList<String> readFile(String pathFile) throws IOException {
        ArrayList<String> list = new ArrayList<>();
        BufferedReader br = new BufferedReader(new FileReader(pathFile));
        String line;
        while ((line = br.readLine()) != null) {
            list.add(line);
        }
        br.close();
        return list;
    }
}

2.5 随机点名器5

在这里插入图片描述

在这里插入图片描述
数据准备
钦逸抒-女-21-0.5
屈燕妮-女-24-1.0
阴诗雁-女-25-1.0
伯荷燕-女-24-1.0
欧文新-男-20-0.5
董泽欧-男-18-1.0
滕星磊-男-18-1.0
阚晴岚-女-22-1.0
傅彬远-男-19-1.0
左花依-女-24-0.25

package Test3;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;

public class Test4 {
    public static void main(String[] args) throws IOException {
        //0.获取学生信息
        ArrayList<Student> list = new ArrayList<>();
        BufferedReader br = new BufferedReader(new FileReader("day30_code/src/Test3/names.txt"));
        String line;
        while ((line = br.readLine()) != null) {
            String[] arr = line.split("-");
            Student stu = new Student(arr[0], arr[1], Integer.parseInt(arr[2]), Double.parseDouble(arr[3]));
            list.add(stu);
        }
        br.close();
        //计算总权重
        double weight = 0;
        for (Student stu : list) {
            weight += stu.getWeight();
        }

        //计算每一个人的权重占比
        double[] arr = new double[list.size()];
        int index = 0;
        for (Student s : list) {
            arr[index] = s.getWeight() / weight;
            index++;
        }

        //计算每一个人的权重占比范围
        for (int i = 1; i < arr.length; i++) {
            arr[i] = arr[i] + arr[i - 1];
        }
        System.out.println(Arrays.toString(arr));

        //随机抽取
        double num = Math.random();
        //判断位置-二分查找
        int res = -Arrays.binarySearch(arr, num) - 1;

        Student stu = list.get(res);
        System.out.println(stu);

        //修改当前学生的权重
        double w = stu.getWeight() / 2;
        stu.setWeight(w);

        //将数据写入文件中
        BufferedWriter bw = new BufferedWriter(new FileWriter("day30_code/src/Test3/names.txt"));
        for (Student s : list) {
            bw.write(s.toString());
            bw.newLine();
        }
        bw.close();


    }
}

三、登录注册

3.1 登录注册1

需求：写一个登陆小案例。

    步骤：
        将正确的用户名和密码手动保存在本地的userinfo.txt文件中。
        保存格式为:username=zhangsan&password=123
        让用户键盘录入用户名和密码
                比较用户录入的和正确的用户名密码是否一致
        如果一致则打印登陆成功
                如果不一致则打印登陆失败

package Test4;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

public class Test4 {
    public static void main(String[] args) throws IOException {
        /*需求：写一个登陆小案例。

        步骤：
            将正确的用户名和密码手动保存在本地的userinfo.txt文件中。
            保存格式为:username=zhangsan&password=123
            让用户键盘录入用户名和密码
                    比较用户录入的和正确的用户名密码是否一致
            如果一致则打印登陆成功
                    如果不一致则打印登陆失败*/

        //0.获取数据
        BufferedReader br = new BufferedReader(new FileReader("day30_code\\src\\Test4\\userinfo.txt"));
        String line = br.readLine();
        br.close();

        //1.处理数据
        String[] arr = line.split("&");
        //用户名
        String[] arr1 = arr[0].split("=");
        String rightUserName = arr1[1];
        //密码
        String[] arr2 = arr[1].split("=");
        String rightPassword = arr2[1];

        //用户输入用户名和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String userName = sc.nextLine();
        System.out.println("请输入密码：");
        String passwd = sc.nextLine();

        //判断
        if (userName.equals(rightUserName) && passwd.equals(rightPassword)) {
            System.out.println("登录成功~");
        } else {
            System.out.println("登录失败~");
        }
    }
}

3.2 登录注册2

需求：写一个登陆小案例（添加锁定账号功能）

    步骤：
    	将正确的用户名和密码手动保存在本地的userinfo.txt文件中。
    	保存格式为:username=zhangsan&password=123&count=0
    	让用户键盘录入用户名和密码
    	比较用户录入的和正确的用户名密码是否一致
    	如果一致则打印登陆成功
    	如果不一致则打印登陆失败，连续输错三次被锁定

public static void main(String[] args) throws IOException {
        /*需求：写一个登陆小案例（添加锁定账号功能）

        步骤：
        	将正确的用户名和密码手动保存在本地的userinfo.txt文件中。
        	保存格式为:username=zhangsan&password=123&count=0
        	让用户键盘录入用户名和密码
        	比较用户录入的和正确的用户名密码是否一致
        	如果一致则打印登陆成功
        	如果不一致则打印登陆失败，连续输错三次被锁定*/

        //0.获取数据
        BufferedReader br = new BufferedReader(new FileReader("day30_code\\src\\Test5\\userinfo.txt"));
        String line = br.readLine();
        br.close();

        //1.处理数据
        String[] arr = line.split("&");
        String rightUserName = arr[0].split("=")[1];
        String rightPasswd = arr[1].split("=")[1];
        String countStr = arr[2].split("=")[1];
        int count = Integer.parseInt(countStr);


        //2.用户输入数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = sc.nextLine();
        System.out.println("请输入密码：");
        String passwd = sc.nextLine();

        //3.判断用户名/密码是否正确
        if (rightUserName.equals(username) && rightPasswd.equals(passwd)) {
            //判断count是否大于3，是 则提示账号已经被锁定，终止程序运行
            if (count > 3) {
                System.out.println("当前账号已经被锁定，请联系管理员！");
                System.exit(0);
            }
            System.out.println("登录成功~");
            writeInfo("username=zhangsan&password=123&count=0");

        } else {
            count++;
            if (count < 3) {
                System.out.println("登录失败,还剩下" + (3 - count) + "次机会~");
            } else {
                System.out.println("用户账号被锁定！");
            }
            writeInfo("username=zhangsan&password=123&count=" + count);
        }
    }

    private static void writeInfo(String content) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("day30_code\\src\\Test5\\userinfo.txt"));
        bw.write(content);
        bw.newLine();
        bw.close();
    }

3.3 登录注册3

在这里插入图片描述

斗地主综合项目链接

获取用户信息：

private void readUserInfo() {
        List<String> userInfoList = FileUtil.readUtf8Lines("G:\\code\\Java\\basic_code\\puzzlegame\\userinfo.txt");
        for (String str : userInfoList) {
            String[] arr = str.split("&");
            String[] arr1 = arr[0].split("=");
            String[] arr2 = arr[1].split("=");

            User u =new User(arr1[1],arr2[1]);
            allUsers.add(u);
        }

        System.out.println(allUsers);
    }

在这里插入图片描述

public void mouseClicked(MouseEvent e) {
        if (e.getSource() == submit) {
            //点击了注册按钮

            //0.用户名，密码不能为空
            if (username.getText().length() == 0 || password.getText().length() == 0 || rePassword.getText().length() == 0) {
                showDialog("用户名和密码不能为空");
                return;
            }

            //1.判断两次密码输入是否一致
            if (!password.getText().equals(rePassword.getText())) {
                showDialog("两次密码输入不一致");
                return;
            }

            //2.判断用户名和密码的格式是否正确
            if (!username.getText().matches("[a-zA-Z0-9]{4,16}")) {
                showDialog("用户名格式不正确，必须是4~16位");
                return;
            }

            if (!password.getText().matches("\\S*(?=\\S{6,})(?=\\S*\\d)(?=\\S*[A-Z])(?=\\S*[a-z])\\S*")) {
                showDialog("密码格式不正确，最少六位，至少包含一个大写字母，一个小写字母！");
                return;
            }

            //3.判断用户名是否已经重复
            if (containsUserName(username.getText())){
                showDialog("用户名已经存在，请重新输入");
                return;
            }
            //4.添加用户
            allUsers.add(new User(username.getText(),password.getText()));

            //5.写入文件
            FileUtil.writeLines(allUsers,"G:\\code\\Java\\basic_code\\puzzlegame\\userinfo.txt","UTF-8");

            //6.提示注册成功
            showDialog("注册成功！");
            this.setVisible(false);
            new LoginJFrame();

        } else if (e.getSource() == reset) {
            //点击了重置按钮
            //清空三个输入框
            username.setText("");
            password.setText("");
            rePassword.setText("");
        }
    }
    /*作用：
     *       判断username在集合中是否存在
     * 参数：
     *       用户名
     * 返回值：
     *       true：存在
     *       false：不存在*/
    private boolean containsUserName(String username) {
        for (User u : allUsers) {
            if (u.getUsername().equals(username)){
                return true;
            }
        }
        return false;
    }

在这里插入图片描述

//获取当前是哪个存档被点击了，获取其中的序号
            JMenuItem item = (JMenuItem) obj;
            String str = item.getText();
            int index = str.charAt(2) - '0';

            //直接把游戏的数据写到本地文件中
            try {
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("puzzlegame\\save\\save" + index + ".data"));
                GameInfo gi = new GameInfo(data, x, y, path, step);
                IoUtil.writeObj(oos, true, gi);
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }
            //修改一下存档item上的展示信息
            //存档0(XX步)
            item.setText("存档" + index + "(" + step + "步)");
            //修改一下读档item上的展示信息
            loadJMenu.getItem(index).setText("存档" + index + "(" + step + "步)");

读档：

else if (obj == saveItem0 || obj == saveItem1 || obj == saveItem2 || obj == saveItem3 || obj == saveItem4) {
            //获取当前是哪个存档被点击了，获取其中的序号
            JMenuItem item = (JMenuItem) obj;
            String str = item.getText();
            int index = str.charAt(2) - '0';

            //直接把游戏的数据写到本地文件中
            try {
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("puzzlegame\\save\\save" + index + ".data"));
                GameInfo gi = new GameInfo(data, x, y, path, step);
                IoUtil.writeObj(oos, true, gi);
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }
            //修改一下存档item上的展示信息
            //存档0(XX步)
            item.setText("存档" + index + "(" + step + "步)");
            //修改一下读档item上的展示信息
            loadJMenu.getItem(index).setText("存档" + index + "(" + step + "步)");
        } else if (obj == loadItem0 || obj == loadItem1 || obj == loadItem2 || obj == loadItem3 || obj == loadItem4) {
            //获取当前是哪个读档被点击了，获取其中的序号
            JMenuItem item = (JMenuItem) obj;
            String str = item.getText();
            int index = str.charAt(2) - '0';

            GameInfo gi = null;
            try {
                //可以到本地文件中读取数据
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("puzzlegame\\save\\save" + index + ".data"));
                gi = (GameInfo)ois.readObject();
                ois.close();
            } catch (IOException ioException) {
                ioException.printStackTrace();
            } catch (ClassNotFoundException classNotFoundException) {
                classNotFoundException.printStackTrace();
            }

            data = gi.getData();
            path = gi.getPath();
            step = gi.getStep();
            x = gi.getX();
            y = gi.getY();

            //重新刷新界面加载游戏
            initImage();



        }

public void getGameInfo(){
        //1.创建File对象表示所有存档所在的文件夹
        File file = new File("puzzlegame\\save");
        //2.进入文件夹获取到里面所有的存档文件
        File[] files = file.listFiles();
        //3.遍历数组，得到每一个存档
        for (File f : files) {
            //f ：依次表示每一个存档文件
            //获取每一个存档文件中的步数
            GameInfo gi = null;
            try {
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream(f));
                gi = (GameInfo)ois.readObject();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //获取到了步数
            int step = gi.getStep();

            //把存档的步数同步到菜单当中
            //save0 ---> 0
            //save1 ---> 1
            //...

            //获取存档的文件名 save0.data
            String name = f.getName();
            //获取当存档的序号（索引）
            int index = name.charAt(4) - '0';
            //修改菜单上所表示的文字信息
            saveJMenu.getItem(index).setText("存档" + index + "(" + step + ")步");
            loadJMenu.getItem(index).setText("存档" + index + "(" + step + ")步");
        }