java nio案例 java项目案例分析

Java项目实战-基于I/O流设计的图书馆管理系统项目总结

由于目前学习进度的原因，我还未开始学习数据库等知识，所以为了完成项目要求，这次就使用I/O流的知识来进行存储，将书籍信息，用户信息和日志都保存到各自的文件中，再进行增删改查的操作

---

图书馆管理系统

• Java项目实战-基于I/O流设计的图书馆管理系统项目总结
• 项目描述：

• 项目重点知识
• 功能概述

• 详细代码：

• Test类
• User类
• Books类
• Library类
• InException类
• UserInterface类
• BackstageInterface类
• AllBook类
• FindBook类
• Log类

• 问题与反思：

项目描述：

项目重点知识

• 掌握java基本语法
• 熟悉使用流程控制
• 理解面向对象思想36
• 熟练封装，继承，多态
• 熟悉使用接口，异常
• 熟悉使用集合
• 熟悉掌握I/o流相关操作

功能概述

在我设计的项目里，用户和管理员的登录完全分开。若使用用户登录则无法中途切换为管理员，若使用管理员登录则无法中途切换为用户。

用户界面：

用户进入系统后会看到这张用户界面：

用户界面会展示6种功能，分别是：

1. 全部书籍：展示图书馆中所收藏的全部图书，输出书名与借阅状态，不用的登录即可使用。
2. 查询书籍：可输入书名来查询书籍的详细信息，会展示书名、作者、售价、书籍分类、出版社与借阅状态，不用的登录即可使用。
3. 用户管理;用户通过此界面来进行登录、注册、修改个人信息等操作。

4. 借阅书籍：用户通过此功能进行书籍借阅操作，通过输入书名来选择索要借阅的书籍，登陆后使用。
5. 归还书籍：用户归还所借阅的书籍，会打印出用户所借阅过得书籍，输入书名后确认归还，登陆后使用。
6. 退出系统：结束整个系统。

管理员界面：

管理员需要使用管理员ID来登录管理员界面，有三次尝试机会，都不通过则结束系统。管理员进入系统后会看到这张管理员界面：

管理员界面会展示3 种功能，分别是：

1. 书籍管理：用于管理书籍信息，可以查看全部书籍、查询书籍、添加书籍、修改书籍信息、删除书籍和查看日志。

2. 用户管理： 用于管理用户信息，主要是查看用户列表、查询用户信息与删除用户。

3. 退出系统：结束整个系统。

---

详细代码：

Test类

运行测试类

public class Test {
    public static void main(String[] args) throws Exception {
        Library library = new Library(); //构造Library对象
        library.use(); //调用对象的登录方法。
    }
}

User类

用户属性定义与重写用户toString方法

public class User {
    private String name;//姓名
    private String password;//密码
    private String sex;//性别
    private int age;//年龄
    private long phoneNum;//手机号码
    private String faculty;//院系

    public User(String name,String password,String sex,int age,long phoneNum,String faculty){
        this.name = name;
        this.password = password;
        this.sex = sex;
        this.age = age;
        this.phoneNum = phoneNum;
        this.faculty = faculty;
    }

    public User(){
    }

    @Override//重写toString方法
    public String toString() {
        return name + '\'' + password + '\'' + sex + '\'' + age + '\'' + phoneNum + '\'' + faculty + '\n';
    }

    //get，set方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) { this.password = password; }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public long getPhoneNum() {
        return phoneNum;
    }

    public void setPhoneNum(long phoneNum) {
        this.phoneNum = phoneNum;
    }

    public String getFaculty() {
        return faculty;
    }

    public void setFaculty(String faculty) {
        this.faculty = faculty;
    }
}

Books类

书籍属性定义与重写书籍toString方法

public class Books {
    private String bookName; //书名
    private String author; //作者
    private double price; //价格
    private String category; //分类
    private String press;//出版社
    private boolean state; //状态  true：已借出  false：未借出
    private String borrowName;//借阅人
    private String borrowTime;//借阅时间

    public Books(String bookName, String author, double price, String category, String press, boolean state, String borrowName, String borrowTime){
        this.bookName = bookName;
        this.author = author;
        this.price = price;
        this.category = category;
        this.press = press;
        this.state = state;
        this.borrowName = borrowName;
        this.borrowTime = borrowTime;
    }

    public Books(){
    }

    @Override//重写toString方法
    public String toString() {
        return bookName +'\''+author+'\''+price+'\''+category+'\''+press+'\''+state+'\''+borrowName+'\''+borrowTime+'\n';
    }

    //get，set方法
    public String getBookName() { return bookName; }

    public void setBookName(String bookName) { this.bookName = bookName; }

    public String getAuthor() { return author; }

    public void setAuthor(String author) { this.author = author; }

    public double getPrice() { return price; }

    public void setPrice(double price) { this.price = price; }

    public String getCategory() { return category; }

    public void setCategory(String category) { this.category = category; }

    public String getPress() { return press; }

    public void setPress(String press) { this.press = press; }

    public boolean getState() { return state; }

    public void setState(boolean state) { this.state = state; }

    public String getBorrowName() { return borrowName; }

    public void setBorrowName(String borrowName) { this.borrowName = borrowName; }

    public String getBorrowTime() { return borrowTime; }

    public void setBorrowTime(String borrowTime) { this.borrowTime = borrowTime; }
}

Library类

这里主要是选择以用户还是以管理员登录

import java.util.Scanner;

public class Library {

    Scanner scanner = new Scanner(System.in);
    InException ie = new InException();//排错
    public static final int PASSWORD = 1234;//管理员ID
    public int logInCount;//登录状态输入标志量

    public void use() throws Exception {
        //输入前的用户提示
        System.out.println("===============图书管理系统===============");
        System.out.println(" 请选择登录状态：1.普通用户  2.管理员  3.退出 ");

        //输入排错
        logInCount = ie.inputErr(logInCount);

        //以用户身份进入
        if (logInCount == 1){
            System.out.println("欢迎使用本系统");
            UserInterface userInterface = new UserInterface();
            userInterface.userMenu();

        }

        //以管理员身份进入
        if (logInCount == 2){
            System.out.println("==========请输入身份ID==========");
            int times = 3;//最大输入次数
            int key = 0;//定义管理员ID

            //输入次数判定
            while(times > 0){
                System.out.print("请输入ID：");
                key = ie.inputErr(key);//管理员输入ID

                //输入错误判断与提示（完）
                if (key != PASSWORD){
                    //3次全错，退出系统（完）
                    if (times <= 1){
                        times = 0;
                        System.out.println("超过最大次数，退出系统");
                        System.exit(0);
                    }
                    System.out.println("ID不正确，请重新输入，目前还可尝试" + (times-1) + "次");
                    times--;
                }

                //输入正确判断与提示
                if (key == PASSWORD){
                    times = 0;
                    System.out.println("欢迎金馆长！");
                    BackstageInterface backstageInterface = new BackstageInterface();
                    backstageInterface.rootMenu();
                }
            }

        }

        //退出程序(完)
        if (logInCount >= 3 || logInCount <= 0){
            System.out.println("即将结束系统，感谢您的使用！");
            System.exit(0);
        }
    }
}

InException类

这里主要是排除输入异常的，将非数字的输入挡在外面。这里其实可以进行优化，不必结束系统。

import java.util.Scanner;

public class InException {
    Scanner scanner = new Scanner(System.in);
    public int inputErr(int count){
        try{
            count = scanner.nextInt();//输入你的选择选择
        }catch (Exception e){
            System.err.println("输入不符合规范退出系统");
            System.exit(0);
        }
        return count;
    }
}

UserInterface类

用户界面，用户可以使用的所有功能都在其中

import Books.AllBook;
import Books.FindBook;

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Scanner;

public class UserInterface {

    Scanner scanner = new Scanner(System.in);
    InException ie = new InException();//排错
    File fileUser = new File("用户信息.txt");
    File fileBook = new File("书籍.txt");
    User user = new User();//存放的是现在正在进行操作的用户信息
    List<String> listUser = new ArrayList<>();//创建个list集合，登录处最开始使用
    List<String> listBook = new ArrayList<>();//创建个list集合，存放书籍信息
    boolean managementFlag = true, modifyFlag = true;//while循环标志位，分别是：用户管理界面标志量/修改信息界面标志量
    public int userCount;//用户菜单输入标志量
    public int userInfoCount;//用户管理界面输入标志量
    public int userModifyCount;//修改信息界面输入标志量
    public int borrowBookIf;//借阅界面确认输入标志量
    public long dayTime = 30;//最大借阅时间设定
    String nowUser;//现在使用系统的用户信息

    //用户菜单
    public void userMenu() throws Exception {
        while (true) {
            System.out.println("==========图书管理系统==========");
            System.out.println(" 1.全部图书 2.查询书籍 3.用户管理 ");
            System.out.println(" 4.借阅书籍 5.归还书籍 6.退出系统 ");
            userCount = ie.inputErr(userCount);//排错

            //全部图书(完)
            if (userCount == 1) {
                AllBook allBook = new AllBook();
                allBook.allBooks();
                System.out.println(" ");
            }

            //查询书籍(完)
            if (userCount == 2) {
                FindBook findBook = new FindBook();
                findBook.findBooks();
                System.out.println(" ");
            }

            //用户管理(完)
            if (userCount == 3) {
                userManagement();//本类用户管理界面方法
                System.out.println(" ");
            }

            //借阅书籍
            if (userCount == 4) {

                //读取书籍文件写进list
                BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
                String bookString;
                while ((bookString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
                    listBook.add(bookString);//一行放入一位list集合
                }
                reader.close();//关闭流

                userBorrowBooks();
                listBook.clear();//清空list，避免下次修改时内有数据重复写入
                System.out.println(" ");
            }

            //归还书籍
            if (userCount == 5) {

                //读取书籍文件写进list
                BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
                String bookString;
                while ((bookString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
                    listBook.add(bookString);//一行放入一位list集合
                }
                reader.close();//关闭流

                userReturnBooks();
                listBook.clear();//清空list，避免下次修改时内有数据重复写入
                System.out.println(" ");
            }

            //退出(完)
            if (userCount >= 6 || userCount <= 0) {
                System.out.println("即将结束系统，感谢您的使用！");
                System.exit(0);
            }
        }
    }



    //3#用户管理界面(完)
    public void userManagement() throws Exception {
        managementFlag = true;
        while (managementFlag) {
            System.out.println("=======用户管理界面======");
            System.out.println(" 1.登录 2.注册 3.修改信息 ");
            System.out.println("   输入其他数字返回上一层  ");

            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileUser)));//缓冲流读取一个转换后的字符流数据
            String tempString;
            while ((tempString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
                listUser.add(tempString);//一行放入一位list集合
            }
            reader.close();//关闭流
            //System.out.println(listUser.size());

            userInfoCount = ie.inputErr(userInfoCount);//排错

            //登录(完)
            if (userInfoCount == 1) {
                userLogin();
                listUser.clear();
                break;
            }

            //注册(完)
            if (userInfoCount == 2) {
                userSignUp();
                listUser.clear();
                System.out.println(" ");
            }

            //修改信息(完)
            if (userInfoCount == 3) {
                userModify();
                listUser.clear();
                System.out.println(" ");
            }

            //返回上一层(完)
            if (userInfoCount >= 4 || userInfoCount <= 0) {
                managementFlag = false;
            }

        }
    }

    //3.1#用户管理界面——登录界面(完)
    public void userLogin () throws Exception{
        System.out.println("=======登   录======");
        System.out.print("请输入用户名：");
        String userLoginName = scanner.next();

        System.out.print("请输入密码：");
        String userLoginPassword = scanner.next();

        //用户信息一个人也没有，直接跳出（完）
        if (listUser.size() == 0){
            System.out.println("第一位用户你好，请先注册");
        }

        //判断输入的用户名是否存在
        boolean flag = false;
        String[] userInf = new String[6];//开辟一个6位的String数组

        //增强for判断用户名是否存在
        for (String users : listUser) {
            userInf = users.split("\'");//检测分隔符为" ' "

            //判断用户名是否存在
            if (userLoginName.equals(userInf[0])) {
                flag = true;
                break;
            }
        }

        //如果存在，判断密码是否正确
        if (flag){
            if (userLoginPassword.equals(userInf[1])) {
                System.out.println("登陆成功");
                //把当前用户信息放入User
                user.setName(userInf[0]);
                user.setPassword(userInf[1]);
                user.setSex(userInf[2]);
                user.setAge(Integer.parseInt(userInf[3]));
                user.setPhoneNum(Long.parseLong(userInf[4]));
                user.setFaculty(userInf[5]);

                //把当前用户信息放入一个字符串中
                nowUser = (userInf[0] + '\'' + userInf[1] + '\'' + userInf[2] + '\'' + userInf[3] + '\'' + userInf[4] + '\'' + userInf[5]);

                //记录日志
                Log log = new Log(userInf[0]);
                log.logRecord("登录了系统");

            } //登陆成功
            else {
                System.out.println("密码错误");
            }//密码错误
        }
        else {
            System.out.println("用户名不存在");
        }//用户名不存在
    }

    //3.2#用户管理界面——注册界面(完)
    public void userSignUp () throws Exception{
        String[] userInf = new String[6];//开辟一个6位的String数组,存放用户list的每一行

        System.out.println("=======注   册======");
        System.out.print("请输入用户名：");
        String userSignUpName;
        boolean repeat = false;
        do {
            userSignUpName = scanner.next();
            for (String users : listUser) {
                userInf = users.split("'");//检测分隔符为" ' "
                if (userSignUpName.equals(userInf[0])) {
                    System.out.print("*用户名重名，请重新输入：");
                    repeat = true;
                    break;
                }
            }
            if (!userSignUpName.equals(userInf[0])){
                repeat = false;
            }
        }while (repeat == true);//重名判断

        System.out.print("请输入密码：");
        String userSignUpPassword = scanner.next();

        System.out.print("请输入您的性别：");
        String userSignUpSex = scanner.next();

        System.out.print("请输入您的年龄：");
        int userSignUpAge=1;
        do {
            while (!scanner.hasNextInt()) {
                //没有这一行的话会导致无限循环
                String userAge = scanner.next();
                System.out.print("不是数字，重新输入年龄");
            }//当是数字时循环结束
            userSignUpAge = scanner.nextInt();

            if (userSignUpAge <= 0){
                System.out.println("请正确输入年龄");
            }
        }while(userSignUpAge <= 0);//不能为负数

        System.out.print("请输入您的手机号码：");
        long userSignUpPhone=1;
        do {
            while (!scanner.hasNextInt()) {
                //没有这一行的话会导致无限循环
                String userPhone = scanner.next();
                System.out.print("不是数字，重新输入手机号码");
            }//当是数字时循环结束
            userSignUpPhone = scanner.nextLong();

            if (userSignUpPhone <= 0){
                System.out.println("请正确输入手机号");
            }
        }while (userSignUpPhone <=0);//不能为负数

        System.out.print("请输入您的所在院系：");
        String userSignUpFaculty = scanner.next();

        //创建对象
        User signUpUser = new User(userSignUpName, userSignUpPassword, userSignUpSex, userSignUpAge, userSignUpPhone, userSignUpFaculty);

        fileUser.createNewFile();//根据抽象路径创建一个新的空文件，当抽象路径制定的文件存在时，创建失败
        FileWriter fileWriter = new FileWriter(fileUser, true);//为false时是覆盖写入
        fileWriter.write(signUpUser.toString());//写入对象
        fileWriter.close();//关闭流
        System.out.println("注册成功！");

        //记录日志
        Log log = new Log(userSignUpName);
        log.logRecord("注册了账号");
    }

    //3.3#用户管理界面——修改信息界面(完)
    public void userModify () throws Exception{
        modifyFlag = true;
        boolean ioFlag = false;//IO修改标志位
        String modify = null;//修改用字符串
        String[] userInf = new String[6];//开辟一个6位的String数组,存放用户list的每一行

        //未登录提示
        if (user.getName() == null){
            System.out.println("你还未登录，请先去登录");
            modifyFlag = false;
        }

        //修改信息操作，内存
        while(modifyFlag){
            System.out.println("==========修改信息==========");
            System.out.print("1.姓   名:" + user.getName() + "\t");
            System.out.println("2.密   码:" + user.getPassword());
            System.out.print("3.性   别:" + user.getSex() + "\t");
            System.out.println("4.年   龄:" + user.getAge());
            System.out.print("5.手机号码:" + user.getPhoneNum() + "\t");
            System.out.println("6.所在院系:" + user.getFaculty());
            System.out.println("     *输入其他数字确认修改*     ");
            System.out.print("请输入要修改的数据序号：");
            //修改数据临时存放字符串
            modify = (user.getName()+'\''+user.getPassword()+'\''+user.getSex()+'\''+user.getAge()+'\''+user.getPhoneNum()+'\''+user.getFaculty());
//            System.out.println(modify);
            userModifyCount = ie.inputErr(userModifyCount);//排错

            //修改姓名
            if (userModifyCount == 1){
                System.out.print("将姓名改为：");

                String userModifyName;
                boolean repeat = false;
                do {
                    userModifyName = scanner.next();
                    for (String users : listUser) {
                        userInf = users.split("'");//检测分隔符为" ' "
                        if (userModifyName.equals(userInf[0])) {
                            System.out.print("*用户名重名，请重新输入：");
                            repeat = true;
                            break;
                        }
                    }
                    if (!userModifyName.equals(userInf[0])){
                        repeat = false;
                    }
                }while (repeat == true);//重名判断

                user.setName(userModifyName);
            }
            //修改密码
            if (userModifyCount == 2){
                System.out.print("将密码改为：");
                String userModifyPassword = scanner.next();
                user.setPassword(userModifyPassword);
            }
            //修改性别
            if (userModifyCount == 3){
                System.out.print("将性别改为：");
                String userModifySex = scanner.next();
                user.setSex(userModifySex);
            }
            //修改年龄
            if (userModifyCount == 4){
                System.out.print("将年龄改为：");
                while (!scanner.hasNextInt()) {
                    //没有这一行的话会导致无限循环
                    String userAge = scanner.next();
                    System.out.print("不是数字，重新输入年龄");
                }//当是数字时循环结束
                int userModifyAge = scanner.nextInt();
                user.setAge(userModifyAge);
            }
            //修改手机号码
            if (userModifyCount == 5){
                System.out.print("将手机号码改为：");
                while (!scanner.hasNextInt()) {
                    //没有这一行的话会导致无限循环
                    String userPhone = scanner.next();
                    System.out.print("不是数字，重新输入年龄");
                }//当是数字时循环结束
                long userModifyPhone = scanner.nextLong();
                user.setPhoneNum(userModifyPhone);
            }
            //修改所在院系
            if (userModifyCount == 6){
                System.out.print("将所在院系改为：");
                String userModifyFaculty = scanner.next();
                user.setFaculty(userModifyFaculty);
            }
            //退出，确认修改（完）
            if (userModifyCount >= 7 || userModifyCount <= 0){
                System.out.println("修改成功,退出修改界面");
                ioFlag = true;
                break;
            }

            System.out.println("\n修改后：");
        }

        //IO修改操作,存储
        if(ioFlag){
            //对用户列表进行操作
            for (int i = 0; i < listUser.size(); i++) {		//遍历
                if(nowUser.equals(listUser.get(i))) {		//如果list中存在与nowUser相同的值，则用modify替换
                    listUser.set(i, modify);				//设置索引为i的值为modify
                }
            }

            //将修改过的用户列表写入文件
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileUser)));//缓冲流读取一个转换后的字符流数据
            String strModify;
            while ((strModify = reader.readLine()) != null) {//循环读取，readLine是读一行内容
                if (strModify.equals(nowUser)) {//读到的与现在运行中的用户数据相同
                    FileWriter fileWriter = new FileWriter(fileUser, false);//为false时是覆盖写入,写入对象
                    for (String s : listUser) {        //遍历
                        fileWriter.write(s + "\n");//写入对象
                    }
                    fileWriter.close();//关闭流
                }
            }
            reader.close();//关闭流

            //记录日志
            Log log = new Log(user.getName());
            log.logRecord("修改了账号信息"+
                    "\n原："+nowUser+
                    "\n现："+modify);

            nowUser = modify;//替换nowUser的值,为了下次修改

        }
    }



    //4#借阅书籍界面(完)
    public void userBorrowBooks() throws Exception{
        String[] bookInf = new String[8];//开辟一个8位的String数组,存放图书list的每一行
        String nowBook = null;//存放需要借阅的书籍
        String needBook;//存放借阅书籍的信息，修改了借阅状态,借阅人和时间

        if (user.getName() != null){
            System.out.println("========借阅书籍=======");
            System.out.print("请输入要借阅的书名：");
            String borrowBookName = scanner.next();

            //增强for循环，打印要借阅的书籍信息
            boolean flag = false;
            for (String users : listBook) {
                bookInf = users.split("'");//检测分隔符为" ' "

                //书籍被借出的判断
                if (borrowBookName.equals(bookInf[0]) && bookInf[5].equals("true")){
                    System.out.println("书籍已被他人借走，你无法借阅");
                    return;
                }

                //找到书籍的判断
                if (borrowBookName.equals(bookInf[0])) {

                    //打印找到的书籍
                    System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                    System.out.println("书名 \t \t作者");
                    System.out.println(bookInf[0]+" \t "+ bookInf[1]);
                    System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                    System.out.println("售价 \t分类 \t \t \t出版社 \t \t借阅状态");
                    System.out.println(bookInf[2]+" \t "+ bookInf[3]+" \t "+ bookInf[4]+" \t "+ bookInf[5]);
                    System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

                    //把当前书籍放入一个字符串中
                    nowBook=(bookInf[0]+'\''+bookInf[1]+'\''+bookInf[2]+'\''+bookInf[3]
                            +'\''+bookInf[4]+'\''+bookInf[5] +'\''+bookInf[6]+'\''+bookInf[7]);

                    flag = true;
                    break;
                }
            }

            //借书判断
            if(flag) {
                System.out.println("是否借阅? 确认(1) 取消（2）");
                borrowBookIf = ie.inputErr(borrowBookIf);//输入排错

                if (borrowBookIf == 1) {

                    //读出现在的时间，存入数组
                    Date nowDate = new Date();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String borrowTime = sdf.format(nowDate);

                    //借出信息放入一个字符串中
                    needBook=(bookInf[0]+'\''+bookInf[1]+'\''+bookInf[2]+'\''+bookInf[3]
                            +'\''+bookInf[4]+'\''+true +'\''+user.getName()+'\''+borrowTime);

                    //System.out.println(listBook);
                    for (int i = 0; i < listBook.size(); i++) {
                        if (nowBook.equals(listBook.get(i))) {
                            listBook.set(i, needBook);//将借阅信息放入其中
                        }
                    }//遍历修改list里的信息
                    //System.out.println(listBook);

                    //I/O操作
                    FileWriter fileWriter = new FileWriter(fileBook);//写入对象
                    for (String s : listBook) {        //遍历
                        fileWriter.write(s + "\n");//写入对象
                    }
                    fileWriter.close();//关闭流

                    System.out.println("于 "+ borrowTime +" 借阅成功，请于"+ dayTime +"秒内归还，逾期将处以罚金");

                    //记录日志
                    Log log = new Log(user.getName());
                    log.logRecord("借阅了图书 "+"《"+ bookInf[0] +"》");

                }//确认借书
                else {
                    System.out.println("取消借书");
                }//取消借书
            }
            else{
                System.out.println("未找到该书籍");
            }//没找到书籍的判断
        }//已登录
        else{
            System.out.println("你还未登陆，请先登录再来借阅书籍");
        }//未登录

    }



    //5#归还书籍界面(完)
    public void userReturnBooks() throws Exception{

        String[] bookInf = new String[8];//开辟一个8位的String数组,存放图书list的每一行
        String nowBook = null;//存放需要借阅的书籍

        if (user.getName() != null){

            //增强for循环，打印所借阅的书籍信息
            boolean flag = false;
            System.out.println("===========你所借阅的书籍有===========");
            for (String users : listBook) {
                bookInf = users.split("'");//检测分隔符为" ' "

                //找到用户借阅的书籍
                if (bookInf[5].equals("true") && user.getName().equals(bookInf[6])){
                    System.out.print(bookInf[0] + "\t");

                }
            }//打印借出的书籍
            System.out.println("\n====================================");
            //System.out.println(listBook);
            System.out.println("请选择你要归还的书籍");
            String returnBookName = scanner.next();

            //归还图书+判断是逾期
            for (String users : listBook) {
                bookInf = users.split("'");//检测分隔符为" ' "

                //归还用户借阅的书籍
                if (returnBookName.equals(bookInf[0]) && user.getName().equals(bookInf[6])){
                    //将现在的书放入nowBook
                    nowBook=(bookInf[0]+'\''+bookInf[1]+'\''+bookInf[2]+'\''+bookInf[3]
                            +'\''+bookInf[4]+'\''+bookInf[5] +'\''+bookInf[6]+'\''+bookInf[7]);

                    //判断是否超时，超时需付罚金
                    Date nowDate = new Date();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String returnTime = sdf.format(nowDate);//获取归还时间
                    Date d1 = sdf.parse(bookInf[7]);//借出时间
                    Date d2 = sdf.parse(returnTime);//归还时间
                    long charge = (d2.getTime() - d1.getTime()) / (1000);//秒
                    //long charge1 = (d2.getTime() - d1.getTime()) / (24 * 60 * 60 * 1000);//天

                    //逾期书籍将缴纳罚金
                    if (charge <= dayTime) {
                        System.out.println("该书籍被您借出" + charge + "秒,感谢您规范用书！");
                    } else if (charge > dayTime) {
                        System.out.println("该书籍被您借出" + charge + "秒,您已逾期" + (charge - dayTime) + "秒,需交罚金：" + ((charge - dayTime)/10) * 2 + "元,谢谢配合！");
                    }
//                if (charge1 <= 7) {
//                    System.out.println("该书籍被您借出" + charge1 + "天,感谢您规范用书！");
//                } else if (charge1 > 7) {
//                    System.out.println("该书籍被您借出" + charge1 + "天,您已逾期" + (charge1 - 7) + "天,需交罚金：" + (charge1 - 7) * 5 + "元,谢谢配合！");
//                }

                    //清除借阅状态和借阅人，借阅时间
                    for (int i = 0; i < listBook.size(); i++) {
                        if (nowBook.equals(listBook.get(i))) {
                            listBook.set(i, bookInf[0]+'\''+bookInf[1]+'\''+bookInf[2]+'\''+bookInf[3]
                                    +'\''+bookInf[4]+'\''+false+'\''+null+'\''+null);
                        }//将借出状态变为false，借阅人，时间清空
                    }//遍历修改list里的信息

                    //记录日志
                    Log log = new Log(user.getName());
                    log.logRecord("归还了图书 "+"《"+ bookInf[0] +"》");

                    flag = true;
                    break;
                }

                //没有借阅该书的判断
                if (returnBookName.equals(bookInf[0]) && !(user.getName().equals(bookInf[6]))){
                    System.out.println("你并没有借阅这本书，无法归还");
                }
            }
            //System.out.println(listBook);

            if (flag){
                //I/O操作
                FileWriter fileWriter = new FileWriter(fileBook);//写入对象
                for (String s : listBook) {        //遍历
                    fileWriter.write(s + "\n");//写入对象
                }
                fileWriter.close();//关闭流
            }//I/O操作

        }//已登录
        else{
            System.out.println("你还未登陆，请先登录再来归还书籍");
        }//未登录
    }



}

BackstageInterface类

管理员界面，管理员可以使用的所有功能都在其中

import Books.AllBook;
import Books.FindBook;
import Books.Books;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class BackstageInterface {
    Scanner scanner = new Scanner(System.in);
    File fileUser = new File("用户信息.txt");
    File fileBook = new File("书籍.txt");
    InException ie = new InException();//排错
    Books books = new Books();//图书类
    List<String> rootListUser = new ArrayList<>();//创建个存放用户的list集合
    List<String> rootListBook = new ArrayList<>();//创建个存放图书的list集合
    String[] userInf = new String[6];//开辟一个6位的String数组,存放用户list的每一行
    String[] bookInf = new String[8];//开辟一个6位的String数组,存放书籍list的每一行
    public int rootCount;//管理员菜单输入标志量
    public int rootBookCount;//书籍管理界面输入标志量
    public int rootUserInfoCount;//用户管理界面输入标志量
    public int bookModifyCount;//书籍修改界面输入标志量
    public int delUserIf;//用户删除判断
    public int delBookIf;//书籍删除判断
    boolean managementFlag = true,modifyFlag = true;//while循环标志位，用户管理界面标志量/修改信息界面标志量


    public void rootMenu() throws Exception {
        while (true) {
            System.out.println("==========金馆长的管理系统==========");
            System.out.println("   1.书籍管理 2.用户管理 3.退出系统  ");
            rootCount = ie.inputErr(rootCount);//排错

            //书籍管理
            if (rootCount == 1) {
                bookManagement();
                System.out.println(" ");
            }

            //用户管理(完)
            if (rootCount == 2) {
                rootUserManagement();
                System.out.println(" ");
            }

            //退出(完)
            if (rootCount > 2 || rootCount < 1) {
                System.out.println("即将结束系统，感谢您的使用！");
                System.exit(0);
            }
        }
    }

    //1#书籍管理界面
    public void bookManagement() throws Exception{
        managementFlag = true;
        while (managementFlag) {
            System.out.println("========书 籍 管 理 界 面=======");
            System.out.println(" 1.全部图书 2.查询书籍 3.增加书籍 ");
            System.out.println(" 4.查看日志 5.书籍修改 6.删除书籍 ");
            System.out.println("      输入其他数字返回上一层      ");

            //读取文件写进list
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
            String bookString;
            while ((bookString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
                rootListBook.add(bookString);//一行放入一位list集合
            }
            reader.close();//关闭流

            //System.out.println(rootListBook.size());//观察集合长度，保证不重复读取

            rootBookCount = ie.inputErr(rootBookCount);//排错

            //全部图书界面(完)
            if (rootBookCount == 1){
                AllBook allBook = new AllBook();
                allBook.allBooks();
                rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
                System.out.println(" ");
            }

            //查询书籍界面(完)
            if (rootBookCount == 2){
                FindBook findBook = new FindBook();
                findBook.findBooks();
                rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
                System.out.println(" ");
            }

            //增加书籍界面(完)
            if (rootBookCount == 3){
                addBook();
                rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
                System.out.println(" ");
            }

            //查看日志界面
            if (rootBookCount == 4){
                Log log = new Log();
                log.logRead();
                rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
                System.out.println(" ");
            }

            //书籍修改界面(完)
            if (rootBookCount == 5){
                modifyBook();
                rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
                System.out.println(" ");
            }

            //删除书籍界面(完)
            if (rootBookCount == 6){
                deleteBook();
                rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
                System.out.println(" ");
            }

            //返回上一层(完)
            if (rootBookCount > 6 || rootBookCount < 1) {
                managementFlag = false;
                rootListBook.clear();//清空list，避免下次修改时内有数据重复写入,bug
            }
        }
    }

    //1.3#书籍管理界面——增加书籍界面(完)
    public void addBook () throws Exception{
        System.out.println("=======增加书籍======");
        System.out.print("请输入书名：");
        String addBookName;
        boolean repeat = false;
        do {
            addBookName = scanner.next();
            for (String users : rootListBook) {
                bookInf = users.split("'");//检测分隔符为" ' "
                if (addBookName.equals(bookInf[0])) {
                    System.out.print("*书籍重名，请重新输入：");
                    repeat = true;
                    break;
                }
            }
            if (!addBookName.equals(bookInf[0])){
                repeat = false;
            }
        }while (repeat == true);//重名判断

        System.out.print("请输入书籍作者：");
        String addBookAuthor = scanner.next();

        System.out.print("请输入书籍价格：");
        double addBookPrice=1;
        do {
            while (!scanner.hasNextDouble()) {
                //没有这一行的话会导致无限循环
                String bookPrice = scanner.next();
                System.out.print("不是数字，重新输入价格");
            }//当是数字时循环结束
            addBookPrice = scanner.nextDouble();
            if (addBookPrice <= 0){
                System.out.println("请正确输入价格");
            }
        }while (addBookPrice <= 0);//不能为负数

        System.out.print("请输入书籍分类：");
        String addBookCategory = scanner.next();

        System.out.print("请输入书籍出版社：");
        String addBookPress = scanner.next();

        //创建对象
        Books addNewBook = new Books(addBookName,addBookAuthor,addBookPrice,addBookCategory,addBookPress,false,null,null);

        fileBook.createNewFile();//根据抽象路径创建一个新的空文件，当抽象路径制定的文件存在时，创建失败
        FileWriter fileWriter = new FileWriter(fileBook, true);//为false时是覆盖写入
        fileWriter.write(addNewBook.toString());//写入对象
        fileWriter.close();//关闭流
        System.out.println("添加成功！");
    }

    //1.5#书籍管理界面——书籍修改界面(完)
    public void modifyBook () throws Exception{
        modifyFlag = true;//标志位为true
        String modify = null;//修改用字符串
        String nowModifyBook = null;//存放现在的书籍
        boolean ioFlag = false;//IO修改标志位
        String[] bookModifyInf = new String[8];//开辟一个8位的String数组,存放图书list的每一行

        System.out.println("========书籍修改=======");
        System.out.print("请确定要修改的书名：");
        String modifyBookName = scanner.next();

        //增强for循环，存入找到的书
        boolean flag = false;
        for (String users : rootListBook) {
            bookModifyInf = users.split("'");//检测分隔符为" ' "

            //书籍被借出的判断
            if (modifyBookName.equals(bookModifyInf[0]) && bookModifyInf[5].equals("true")){
                System.out.println("书籍已被借出，无法修改");
                return;
            }

            if (modifyBookName.equals(bookModifyInf[0])) {
                books.setBookName(bookModifyInf[0]);//存入书名
                books.setAuthor(bookModifyInf[1]);//存入作者
                books.setPrice(Double.parseDouble(bookModifyInf[2]));//存入价格
                books.setCategory(bookModifyInf[3]);//存入类型
                books.setPress(bookModifyInf[4]);//存入出版社
                books.setState(Boolean.parseBoolean(bookModifyInf[5]));//存入借阅状态
                books.setBorrowName(bookModifyInf[6]);//存入借阅人
                books.setBorrowTime(bookModifyInf[7]);//存入借阅时间

                //把当前书籍放入一个字符串中
                nowModifyBook=(bookModifyInf[0]+'\''+bookModifyInf[1]+'\''+bookModifyInf[2]+'\''+bookModifyInf[3]
                        +'\''+bookModifyInf[4]+'\''+bookModifyInf[5] +'\''+bookModifyInf[6]+'\''+bookModifyInf[7]);

                flag = true;
                break;
            }
        }

        if (flag){
            while(modifyFlag){
                System.out.println("来吧 展示：");
                System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                System.out.println("(1)书名 \t \t(2)作者");
                System.out.println(books.getBookName()+" \t "+ books.getAuthor());
                System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                System.out.println("(3)售价 \t(4)分类 \t \t \t(5)出版社");
                System.out.println(books.getPrice()+" \t "+ books.getCategory()+" \t "+ books.getPress());
                System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                System.out.println("     输入其他数字确认修改     ");
                System.out.print("请输入要修改的数据序号：");
                modify=(books.getBookName()+'\''+books.getAuthor()+'\''+books.getPrice()+'\''+books.getCategory()+'\''+
                        books.getPress()+'\''+ bookModifyInf[5]+'\''+ bookModifyInf[6]+'\''+ bookModifyInf[7]);
                //System.out.println("while内"+modify);
                bookModifyCount = ie.inputErr(bookModifyCount);//排错

                //修改书名
                if (bookModifyCount == 1){
                    System.out.print("将书名改为：");
                    String bookModifyName;
                    boolean repeat = false;
                    do {
                        bookModifyName = scanner.next();
                        for (String users : rootListBook) {
                            bookInf = users.split("'");//检测分隔符为" ' "
                            if (bookModifyName.equals(bookInf[0])) {
                                System.out.print("*书籍重名，请重新输入：");
                                repeat = true;
                                break;
                            }
                        }
                        if (!bookModifyName.equals(bookInf[0])){
                            repeat = false;
                        }
                    }while (repeat == true);//重名判断

                    books.setBookName(bookModifyName);
                }
                //修改作者
                if (bookModifyCount == 2){
                    System.out.print("将作者改为：");
                    String bookModifyAuthor = scanner.next();
                    books.setAuthor(bookModifyAuthor);
                }
                //修改售价
                if (bookModifyCount == 3){
                    System.out.print("将售价改为：");
                    while (!scanner.hasNextDouble()) {
                        //没有这一行的话会导致无限循环
                        String userPrice = scanner.next();
                        System.out.print("不是数字，重新输入价格");
                    }//当是数字时循环结束
                    double bookModifyPrice = scanner.nextDouble();
                    books.setPrice(bookModifyPrice);
                }
                //修改分类
                if (bookModifyCount == 4){
                    System.out.print("将分类改为：");
                    String bookModifyCategory = scanner.next();
                    books.setCategory(bookModifyCategory);
                }
                //修改出版社
                if (bookModifyCount == 5){
                    System.out.print("将出版社改为：");
                    String bookModifyPress = scanner.next();
                    books.setPress(bookModifyPress);
                }
                //退出，确认修改（完）
                if (bookModifyCount > 5 || bookModifyCount < 1){
                    System.out.println("修改成功,退出修改界面");
                    ioFlag = true;
                    break;
                }
            }

            //IO修改操作,存储
            if(ioFlag){
                //System.out.println("while外"+rootListBook.size());//排bug
                //对用户列表进行操作
                for (int i = 0; i < rootListBook.size(); i++) {		//遍历
                    if(nowModifyBook.equals(rootListBook.get(i))) {		//如果list中存在与nowBook相同的值，则用modify替换
                        rootListBook.set(i, modify);				//设置索引为i的值为modify
                    }
                }

                //将修改过的用户列表写入文件
                BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
                String strModify;
                while ((strModify = reader.readLine()) != null) {//循环读取，readLine是读一行内容
                    if (strModify.equals(nowModifyBook)) {//读到的与现在运行中的用户数据相同
                        FileWriter fileWriter = new FileWriter(fileBook, false);//为false时是覆盖写入,写入对象
                        for (String s : rootListBook) {        //遍历
                            fileWriter.write(s + "\n");//写入对象
                        }
                        fileWriter.close();//关闭流
                    }
                }
                reader.close();//关闭流
            }
        }//找到的判断
        else{
            System.out.println("书籍不存在");
        }//没找到的判断

        rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
    }

    //1.6#书籍管理界面——删除书籍界面(完)
    public void deleteBook () throws Exception{
        String delBook = null;//存放现在的书籍
        String[] bookDeleteInf = new String[8];//开辟一个8位的String数组,存放图书list的每一行

        System.out.println("========删除书籍=======");
        System.out.print("请确定要删除的书名：");
        String delBookName = scanner.next();
        System.out.print("请确定要删除书的出版社：");
        String delBookPress = scanner.next();

        //增强for循环，打印要删除的书籍信息
        boolean flag = false;
        for (String books : rootListBook) {
            bookDeleteInf = books.split("'");//检测分隔符为" ' "

            //书籍被借出的判断
            if (delBookName.equals(bookDeleteInf[0]) && delBookPress.equals(bookDeleteInf[4]) && bookDeleteInf[5].equals("true")){
                System.out.println("书籍已被借出，无法删除");
                return;
            }

            //找到书籍的判断
            if (delBookName.equals(bookDeleteInf[0]) && delBookPress.equals(bookDeleteInf[4])) {

                //打印找到的书籍
                System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                System.out.println("书名 \t \t作者");
                System.out.println(bookDeleteInf[0]+" \t "+ bookDeleteInf[1]);
                System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                System.out.println("售价 \t分类 \t \t \t出版社 \t \t借阅状态");
                System.out.println(bookDeleteInf[2]+" \t "+ bookDeleteInf[3]+" \t "+ bookDeleteInf[4]+" \t "+ bookDeleteInf[5]);
                System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

                //把当前书籍放入一个字符串中
                delBook=(bookDeleteInf[0]+'\''+bookDeleteInf[1]+'\''+bookDeleteInf[2]+'\''+bookDeleteInf[3]
                        +'\''+bookDeleteInf[4]+'\''+bookDeleteInf[5] +'\''+bookDeleteInf[6]+'\''+bookDeleteInf[7]);

                flag = true;
                break;
            }
        }

        //删除判断
        if(flag) {
            System.out.println("是否删除? 确认(1) 取消（2）");
            delBookIf = ie.inputErr(delBookIf);//输入排错

            if (delBookIf == 1) {
                //System.out.println(rootListBook);
                for (int i = 0; i < rootListBook.size(); i++) {
                    if (delBook.equals(rootListBook.get(i))) {
                        rootListBook.remove(delBook);//删除
                    }
                }//遍历
                //System.out.println(rootListBook);

                FileWriter fileWriter = new FileWriter(fileBook);//写入对象
                for (String s : rootListBook) {        //遍历
                    fileWriter.write(s + "\n");//写入对象
                }
                fileWriter.close();//关闭流

                System.out.println("删除成功");
            }//确认删除
            else {
                System.out.println("取消删除");
            }//取消删除
        }
        else{
            System.out.println("未找到该书籍");
        }//没找到的判断
    }



    //2#用户管理界面(完)
    public void rootUserManagement() throws Exception{
        managementFlag = true;
        while (managementFlag) {
            System.out.println("========用 户 管 理 界 面=======");
            System.out.println(" 1.用户列表 2.用户查询 3.删除用户 ");
            System.out.println("      输入其他数字返回上一层      ");

            //读取文件写进list
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileUser)));//缓冲流读取一个转换后的字符流数据
            String userString;
            while ((userString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
                rootListUser.add(userString);//一行放入一位list集合
            }
            reader.close();//关闭流

            //System.out.println(rootListUser.size());//观察集合长度，保证不重复读取

            rootUserInfoCount = ie.inputErr(rootUserInfoCount);//排错

            //用户列表(完)
            if (rootUserInfoCount == 1) {
                userList();
                rootListUser.clear();//清空list，避免下次修改时内有数据重复写入
                System.out.println(" ");
            }

            //用户查询(完)
            if (rootUserInfoCount == 2) {
                userFind();
                rootListUser.clear();//清空list，避免下次修改时内有数据重复写入
                System.out.println(" ");
            }

            //删除用户(完)
            if (rootUserInfoCount == 3) {

                //读取文件写进list
                BufferedReader readers = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
                String bookString;
                while ((bookString = readers.readLine()) != null) {//循环读取，readLine是读一行内容
                    rootListBook.add(bookString);//一行放入一位list集合
                }
                readers.close();//关闭流

                delUser();
                rootListBook.clear();//清空list，避免下次修改时内有数据重复写入
                rootListUser.clear();//清空list，避免下次修改时内有数据重复写入
                System.out.println(" ");
            }

            //返回上一层(完)
            if (rootUserInfoCount > 3 || rootUserInfoCount < 1) {
                managementFlag = false;
                rootListUser.clear();//清空list，避免下次修改时内有数据重复写入
            }

        }
    }

    //2.1#用户管理界面——用户列表(完)
    public void userList (){
        System.out.println("====================用  户  列  表===================");
        System.out.println("姓名 \t密码 \t性别 \t年龄 \t手机号码 \t所在院系");

        //增强for循环，遍历打印出list
        for (String users : rootListUser) {
            userInf = users.split("'");//检测分隔符为" ' "
            System.out.println(userInf[0]+" \t "+userInf[1]+" \t "+userInf[2]+" \t "+userInf[3]+" \t \t"+userInf[4]+" \t "+userInf[5]);
        }
    }

    //2.2#用户管理界面——用户查询(完)
    public void userFind (){
        System.out.println("=======用户查询======");
        System.out.print("请输入所要查询用户的姓名：");
        String userFindName = scanner.next();

        //增强for循环，打印查找到的用户信息
        boolean flag = false;
        for (String users : rootListUser) {
            userInf = users.split("'");//检测分隔符为" ' "
            if (userFindName.equals(userInf[0])) {
                System.out.println("姓名 \t密码 \t性别 \t年龄 \t手机号码 \t所在院系");
                System.out.println(userInf[0]+" \t "+userInf[1]+" \t "+userInf[2]+" \t "+userInf[3]+" \t \t"+userInf[4]+" \t "+userInf[5]);
                flag = true;
                break;
            }
        }

        //没找到的判断
        if (!flag){
            System.out.println("用户名不存在");
        }
    }

    //2.3#用户管理界面——删除用户(完)
    public void delUser () throws Exception{

        String[] bookInf = new String[8];//开辟一个8位的String数组,存放图书list的每一行

        System.out.println("=======删除用户======");
        System.out.print("请输入所要删除用户的姓名：");
        String delUserName = scanner.next();
        System.out.print("请输入所要删除用户的密码：");
        String delUserPassword = scanner.next();

        //增强for循环，打印将要删除的用户信息
        boolean flag = false;
        String delUser = null;
        for (String users : rootListUser) {
            userInf = users.split("'");//检测分隔符为" ' "

            //书籍被借出的判断
            for (String books : rootListBook) {
                bookInf = books.split("'");//检测分隔符为" ' "
                //书籍被借出的判断
                if (delUserName.equals(userInf[0]) && delUserPassword.equals(userInf[1]) && bookInf[6].equals(delUserName)){
                    System.out.println("书籍已被借出，无法删除用户");
                    return;
                }
            }

            if (delUserName.equals(userInf[0]) && delUserPassword.equals(userInf[1])) {
                System.out.println("姓名 \t密码 \t性别 \t年龄 \t手机号码 \t所在院系");
                System.out.println(userInf[0]+" \t "+userInf[1]+" \t "+userInf[2]+" \t "+userInf[3]+" \t \t"+userInf[4]+" \t "+userInf[5]);
                delUser = (userInf[0]+'\''+userInf[1]+'\''+userInf[2]+'\''+userInf[3]+'\''+userInf[4]+'\''+userInf[5]);//存入数组以便删除
                flag = true;
                break;
            }
        }

        //删除判断
        if (flag){
            System.out.println("是否删除? 确认(1) 取消（2）");
            delUserIf = ie.inputErr(delUserIf);//输入排错

            if (delUserIf == 1){
//                System.out.println(rootListUser);
                for (int i = 0; i < rootListUser.size(); i++) {		//遍历
                    if(delUser.equals(rootListUser.get(i))) {		//如果list中存在与nowUser相同的值，则用modify替换
                        rootListUser.remove(delUser);				//设置索引为i的值为modify
                    }
                }
//                System.out.println(rootListUser);

                FileWriter fileWriter = new FileWriter(fileUser);//写入对象
                for (String s : rootListUser) {        //遍历
                    fileWriter.write(s + "\n");//写入对象
                }
                fileWriter.close();//关闭流

                System.out.println("删除成功");
            }//确认删除
            else{
                System.out.println("取消删除");
            }//取消删除
        }
        else{
            System.out.println("该用户不存在");
        }//该用户不存在

    }
}

AllBook类

打印文件中的全部书籍

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

public class AllBook {

    File fileBook = new File("书籍.txt");
    List<String> allBookList = new ArrayList<>();//创建个list集合
    String[] allBookInf = new String[8];//开辟一个6位的String数组,存放list的每一行

    //全部图书列出来(完)
    public void allBooks() throws Exception {
        System.out.println("========现有书籍&借阅状态=======");
        System.out.println("书籍 \t \t借阅状态");

        //读取文件写进list
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
        String userString;
        while ((userString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
            allBookList.add(userString);//一行放入一位list集合
        }
        reader.close();//关闭流

        //增强for循环，遍历打印出list
        for (String users : allBookList) {
            allBookInf = users.split("'");//检测分隔符为" ' "
            System.out.println(allBookInf[0]+" \t "+" \t "+allBookInf[5]);
        }
    }
}

FindBook类

通过输入要查询的书名查询文件中的书籍

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class FindBook {

    Scanner scanner = new Scanner(System.in);
    File fileBook = new File("书籍.txt");
    List<String> findBookList = new ArrayList<>();//创建个list集合
    String[] findBookInf = new String[8];//开辟一个6位的String数组,存放list的每一行

    //查询图书(完)
    public void findBooks() throws Exception {
        System.out.println("========查询图书=======");
        System.out.print("请输入要查询的书名：");
        String findBookName = scanner.next();

        //读取文件写进list
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileBook)));//缓冲流读取一个转换后的字符流数据
        String userString;
        while ((userString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
            findBookList.add(userString);//一行放入一位list集合
        }
        reader.close();//关闭流

        //增强for循环，打印查找到的用户信息
        boolean flag = false;
        for (String users : findBookList) {
            findBookInf = users.split("'");//检测分隔符为" ' "
            if (findBookName.equals(findBookInf[0])) {
                System.out.println(" ");
                System.out.println("书名 \t \t作者");
                System.out.println(findBookInf[0]+" \t "+findBookInf[1]);
                System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                System.out.println("售价 \t分类 \t \t \t出版社 \t \t借阅状态");
                System.out.println(findBookInf[2]+" \t "+findBookInf[3]+" \t "+findBookInf[4]+" \t "+findBookInf[5]);
                flag = true;
                break;
            }
        }

        //没找到的判断
        if (!flag){
            System.out.println("书籍不存在");
        }
    }
}

Log类

日志的打印与记录功能

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Log {
    private String userNameLog;//姓名

    public Log(){}

    public Log(String userNameLog){
        this.userNameLog = userNameLog;
    }

    //写日志
    public void logRecord(String something) throws Exception {
        File log = new File("日志.txt");//确定日志文件夹
        Date nowDate = new Date();//创建Date对象
        SimpleDateFormat dateSize = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//定义日期格式

        String nowTime = dateSize.format(nowDate);
        FileWriter jfw = new FileWriter(log, true);
        jfw.write(nowTime + " " + userNameLog + something + "\n");
        jfw.write("------------------------------");
        jfw.write(System.getProperty("line.separator"));//在段落后添加一个换行符
        jfw.close();
    }

    //读日志
    public void logRead() throws Exception{

        File fileLog = new File("日志.txt");

        System.out.println("======================== 查  看  日  志 ========================");

        //读取文件写进list
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileLog)));//缓冲流读取一个转换后的字符流数据
        String userString;
        while ((userString = reader.readLine()) != null) {//循环读取，readLine是读一行内容
            System.out.println(userString);//输出日志
        }
        reader.close();//关闭流
    }

    //get，set方法
    public String getUserNameLog() { return userNameLog; }

    public void setUserNameLog(String userNameLog) { this.userNameLog = userNameLog; }
}

---

问题与反思：

在编写项目时，并没有完全掌握面向对象的编写方式，还在用面向过程的方式编写，没有发挥出java的优势。

在定义项目工程的时候没有做好包与类的划分，使得代码显得很凌乱。
由于基础的薄弱耗费了大量时间在补全知识上，导致项目工期时间不够用,自我时间规划不合理。

有很多注释是复制粘贴的未作修改，请见谅。

代码做过bug的检查，但若是还有bug存在，或是其他问题存在，请在评论区指出，我会尽力修改。