java图书馆管理系统（io流）_java 修改图书io流

---

前言

用到了io对象处理流和字符缓冲流的知识，既可以在一个文档里正常显示添加的信息（字符缓冲流），又可以在关闭程序后再打开程序还能读到之前添加的所有信息（对象处理流，对象的序列化）

一、基本结构

首先放一张图，然后我针对里面的具体解释


基本结构这两张图展示的比较清楚；我来解释一下前三包下面的两个文本是啥意思，因为作业是io流写的，之前用对象处理流写了一个作业，发现写进文本里面的是乱码，人类看不懂，但是对象处理流的好处就是，当我们关闭程序，或者关闭idea，再打开这个图书馆系统，我们还可以读到之前存储的对象信息（因为这些信息已经被写到了文本里），比如我们加了几本书，几名读者，以及借阅者的信息，都被保存下来，所以为了保留这个好处，这次我还用了对象处理流，但是我也用了字符处理流，把我们操作的信息展示在另一个文本里，这样我们人类就可以直接看到我们做了 什么事，所以代码写的比较麻烦，对象处理流的乱码文本就是后面带“1”的文本，字符处理流的正常文本就是不带1的文本（我们可以看懂），上两张图展示以下

上图是对象处理流写入的乱码文本，用来永久保存信息
下面展示个字符处理流写入的正常文本，用来给我们看

ok 基本结构说到这里！

二、BOOK包

首先在这里说下，BOOK包和PERSON包很像，BOOK包还更复杂，PERSON包唯一的特点就是我写了个学号查重功能，一会写PERSON包时候我只展示那个查重的代码，不然代码太多了不方便学长看。下面介绍BOOK包的全部类

1丶Book类

用于创建图书的类，包含构造方法
setget函数，toString方法，实现了序列化接口（Serializable）和比较接口（Comparable），代码如下：

package BOOK;

import java.io.Serializable;

public class Book implements Comparable<Book>, Serializable {
    public int bookNum;
    public String bookName;
    public String writer;
    public String publish;
    public BookDate publishDate;//BoodDate类的成员！
    public int remainNum;
    public int price;

    public Book(int bookNum, String bookName, String writer, String publish, BookDate publishDate, int remainNum, int price) {
        this.bookNum = bookNum;
        this.bookName = bookName;
        this.writer = writer;
        this.publish = publish;
        this.publishDate = publishDate;
        this.remainNum = remainNum;
        this.price = price;
    }

    public int getBookNum() {
        return bookNum;
    }

    public void setBookNum(int bookNum) {
        this.bookNum = bookNum;
    }

    public String getBookName() {
        return bookName;
    }

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

    public String getWriter() {
        return writer;
    }

    public void setWriter(String writer) {
        this.writer = writer;
    }

    public String getPublish() {
        return publish;
    }

    public void setPublish(String publish) {
        this.publish = publish;
    }

    public BookDate getPublishDate() {
        return publishDate;
    }

    public void setPublishDate(BookDate publishDate) {
        this.publishDate = publishDate;
    }

    public int getRemainNum() {
        return remainNum;
    }

    public void setRemainNum(int remainNum) {
        this.remainNum = remainNum;
    }

    public int getPrice() {
        return price;
    }

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

    @Override
    public String toString() {
        return "\nBook{" //开头加个\n太细节了，输出每一本书的时候都会换行，更清楚！
                "bookNum=" + bookNum +
                ", bookName='" + bookName + '\'' +
                ", writer='" + writer + '\'' +
                ", publish='" + publish + '\'' +
                ", publishDate=" + publishDate +
                ", remainNum=" + remainNum +
                ", price=" + price +
                '}';
    }

    @Override
    public int compareTo(Book o) {
        return this.getBookName().compareTo(o.getBookName());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

2丶BookDate类

这个类就是为了Book类里面的出版日期而建立的，也需要实现序列化接口
代码如下：

package BOOK;

import java.io.Serializable;

public class BookDate implements Serializable {
    public int year;
    public int month;
    public int day;

    public BookDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return "BookDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

3丶BookShelf类（书架）

该类包含以下六个部分（容器和五大方法）

1.容器

首先建立一个Arraylist容器用来存放我们创建的所有书，因为对象处理流一次只能写入或者读取一个对象，所以我们把所有书都放在容器里面，再把容器看做对象，这样就每次就可以写入或者读取容器里面所有的对象了

ArrayList<Book>book1s=new ArrayList<>();//book1s容器
1

2.添加方法-add（）方法

首先用字节输入流中的available方法读取对象处理流写入文本里的内容，判断文本是否为空，因为如果原文本为空，为空的话就不能读取，会报错（readFully），不为空的话我们才可以读取，所有包的所有方法都应用了这个思路（视频里有展示效果，文本为空的话会告诉我们里面没有任何信息），下面小的不作复述，代码如下：

FileInputStream fil=new FileInputStream("src/BOOK/BookShelf1" );//需要判断的文本的地址
            byte[] by=new byte[1000];
            int size= fil.available();//用字节输入流中的available方法读取文档里的内容，判断文档是否为空
            if(size==0)
1
2
3
4

判断完了以后，针对为空和不为空，我写了两个部分的添加方法，区别就是为空的时候没写对象读取（ObjectInputStream），防止报错，为空的时候因为文本里面没有任何内容，不用考虑覆盖的事，所以我们直接写入就行（不为空的时候不能直接写入）：代码如下：

if(size==0){
                System.out.println("欢迎使用图书添加功能");
                System.out.println("请输入添加图书的书号");
                Scanner scanner=new Scanner(System.in);
                int bookNum= scanner.nextInt();
                System.out.println("请输入添加图书的名字");
                String bookName= scanner.next();
                System.out.println("请输入添加图书的作者");
                String writer=scanner.next();
                System.out.println("请输入添加图书的出版社");
                String publish=scanner.next();
                System.out.println("请输入添加图书的出版日期");
                System.out.println("请输入具体年份");int year=scanner.nextInt();
                System.out.println("请输入当年的具体月份");int month=scanner.nextInt();
                System.out.println("请输入当月具体哪一天");int day=scanner.nextInt();
                BookDate bookDate=new BookDate(year,month,day);
                System.out.println("输入完成，请输入该图书的存馆数量");
                int remainNum=scanner.nextInt();
                System.out.println("请输入该图书的定价");
                int price=scanner.nextInt();
                Book book=new Book(bookNum,bookName,writer,publish,bookDate,remainNum,price);
                System.out.println("添加图书成功！");
                book1s.add(book);//新对象放进数组
                bookNum++;
                BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/BOOK/BookShelf",true)));
                System.out.println("您添加了一本新图书,信息如下，同时信息已保存到文档中");
                System.out.println(book);
                bufferedWriter.write("您添加了一本新图书，信息如下");
                bufferedWriter.newLine();
                bufferedWriter.write(String.valueOf(book));
                bufferedWriter.newLine();
                bufferedWriter.flush();;
                bufferedWriter.close();
                System.out.println("图书添加功能完毕");
                ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("src/BOOK/BookShelf1"));
                oos.writeObject(book1s);
                oos.flush();
                oos.close();
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

！因为对象输出流写入的时候会覆盖原来的对象，所以我们不能直接写入，那样每次之前写入的对象就没了，我们采用先用一个数组对象读取储存原文件的内容，再把原文件清空，在把新添加的对象放进这个数组对象里面，最后再把数组对象写进已经为空的原文件里面，这样就实现了原数据的保存和新数据的添加，BOOK包和PERSON包的添加，删除，修改，排序等方法，都采用了这个思路，下面小的不再复述，代码如下：

else{
                ObjectInputStream ois=new ObjectInputStream(new FileInputStream("src/BOOK/BookShelf1"));
                Object o=ois.readObject();
                ArrayList<Book>books1=(ArrayList<Book>) o;//用一个对象数组读取原文本里面所有的信息
                ois.close();
                FileWriter fileWriter=new FileWriter(new File("src/BOOK/BookShelf1"));
                fileWriter.write("");
                fileWriter.flush();
                fileWriter.close();//以上四行代码，实现了清除原来的文本
                System.out.println("欢迎使用图书添加功能");
                System.out.println("请输入添加图书的书号");
                Scanner scanner=new Scanner(System.in);
                int bookNum= scanner.nextInt();
                System.out.println("请输入添加图书的名字");
                String bookName= scanner.next();
                System.out.println("请输入添加图书的作者");
                String writer=scanner.next();
                System.out.println("请输入添加图书的出版社");
                String publish=scanner.next();
                System.out.println("请输入添加图书的出版日期");
                System.out.println("请输入具体年份");int year=scanner.nextInt();
                System.out.println("请输入当年的具体月份");int month=scanner.nextInt();
                System.out.println("请输入当月具体哪一天");int day=scanner.nextInt();
                BookDate bookDate=new BookDate(year,month,day);
                System.out.println("输入完成，请输入该图书的存馆数量");
                int remainNum=scanner.nextInt();
                System.out.println("请输入该图书的定价");
                int price=scanner.nextInt();
                Book book=new Book(bookNum,bookName,writer,publish,bookDate,remainNum,price);
                System.out.println("添加图书成功！");
                book1s.add(book);
                books1.add(book);
                bookNum++;
                BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/BOOK/BookShelf",true)));
                System.out.println("您添加了一本新图书,信息如下，同时信息已保存到文档中");
                System.out.println(book);
                bufferedWriter.write("您添加了一本新图书，信息如下");
                bufferedWriter.newLine();
                bufferedWriter.write(String.valueOf(book));//在字符处理流写入的正常的文本里面展示我们添加的图书信息
                bufferedWriter.newLine();
                bufferedWriter.flush();;
                bufferedWriter.close();
                System.out.println("图书添加功能完毕");
                ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("src/BOOK/BookShelf1"));//把新数组写进原文件，实现了原数据的保存和新数据的添加
                oos.writeObject(books1);
                oos.flush();
                oos.close();

            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

添加的图书信息不仅会以乱码的形式写进BookShelf1文本里，还会在BookShelf文本里面正常显示他的信息，展示一下结果

添加图书成功！
您添加了一本新图书,信息如下，同时信息已保存到文档中

Book{bookNum=5, bookName='5', writer='5', publish='5', publishDate=BookDate{year=5, month=5, day=5}, remainNum=5, price=5}
图书添加功能完毕
1
2
3
4
5

先在控制台输出你添加的图书信息，文本里面也有，如下：

我们可以在这个文本里面直接看
以上就是添加方法

3.查询方法-seek（)方法

用swich选择查询方式，在我标记的地方我故意没加break语句，这样所有出版社相同的书每次都会被全部查找出来，代码如下：

public void seek() throws Exception {
            FileInputStream fil=new FileInputStream("src/BOOK/BookShelf");
            byte[] by=new byte[1000];
            int size= fil.available();
            if(size==0){
                System.out.println("图书馆暂时没有任何图书信息");
            }else{
                ObjectInputStream ois=new ObjectInputStream(new FileInputStream("src/BOOK/BookShelf1"));
                Object o=ois.readObject();
                ArrayList<Book>books1=(ArrayList<Book>) o;
                ois.close();
                System.out.println("欢迎使用图书查询功能，请选择查询方式");
                System.out.println("1:  书名\n2:  作者名\n3:  出版社");
                Scanner scanner=new Scanner(System.in);
                System.out.println("请输入您的选项");
                int choice=scanner.nextInt();
                switch (choice){
                    case 1:
                        System.out.println("请输入书名");
                        String bookName=scanner.next();
                        for(Book bb:books1){
                            if(bb.getBookName().equals(bookName)){
                                System.out.println(bb);
                            }//未添加break标记，所有书名相同的书都会被查找出来
                        }
                        break;
                    case 2:
                        System.out.println("请输入作者名");
                        String writer=scanner.next();
                        for(Book bb:books1){
                            if(bb.getWriter().equals(writer)){
                                System.out.println(bb);
                            }//未添加break标记，所有作者名相同的书都会被查找出来
                        }
                        break;

                    case 3:
                        System.out.println("请输入出版社");
                        String publish=scanner.next();
                        for(Book bb:books1){
                            if(bb.getPublish().equals(publish)){
                                System.out.println(bb);
                            }//未添加break标记，所有出版社相同的书都会被查找出来
                        }
                        break;
                    default:
                        System.out.println("输入错误");
                }
                System.out.println("图书信息查询功能完毕");
            }
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

演示结果：

欢迎使用图书查询功能，请选择查询方式
1:  书名
2:  作者名
3:  出版社
请输入您的选项
3
请输入出版社
3

Book{bookNum=3, bookName='1', writer='3', publish='3', publishDate=BookDate{year=3, month=3, day=3}, remainNum=1, price=3}

Book{bookNum=3, bookName='3', writer='33', publish='3', publishDate=BookDate{year=3, month=3, day=33}, remainNum=3, price=3}
图书信息查询功能完毕
1
2
3
4
5
6
7
8
9
10
11
12
13

如上图，所有出版社是3的书都被打印了出来

4.排序方法-sort（）方法

Arraylist里面本来就有sort方法，我这里重写了一下，先按照书号排序，书号相同的话再按照书名排序，都是升序，会在文本和控制台里面展示排序完成后的结果，下面先展示代码：

public void sort() throws Exception {
                FileInputStream fil=new FileInputStream("src/BOOK/BookShelf");
                byte[] by=new byte[1000];
                int size= fil.available();
                if(size==0){
                    System.out.println("图书馆暂时没有任何图书信息");
                }else{
                    ObjectInputStream ois=new ObjectInputStream(new FileInputStream("src/BOOK/BookShelf1"));
                    Object o=ois.readObject();
                    ArrayList<Book>books1=(ArrayList<Book>) o;
                    ois.close();
                    System.out.println("欢迎使用图书排序功能，正在自动排序");
                    books1.sort(new Comparator<Book>() {
                        @Override
                        public int compare(Book o1, Book o2) {
                            int i=o1.getBookNum()-o2.getBookNum();
                            if(i!=0){
                                return i;//按照书号的升序来排序
                            }
                            int j=o1.compareTo(o2);
                            if(j!=0){
                                return j;//书号相同的再按照书名的升序排序
                            }else {
                                return 0;
                            }
                        }
                    });
                        System.out.println("排序后的结果如下，同时排序操作结果已经保存到文档中");
                        System.out.println(books1);
                        BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/BOOK/BookShelf",true)));
                        bufferedWriter.write("排序后的结果如下");
                        bufferedWriter.newLine();
                        bufferedWriter.write(String.valueOf(books1));
                        bufferedWriter.newLine();
                        bufferedWriter.flush();;
                        bufferedWriter.close();
                        System.out.println("排序操作完毕");
                }

            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

控制台里面的结果

欢迎来到图书板块，请选择您要进行的操作
1:添加图书	2:查询图书	3:图书排序	4:图书修改	5:图书删除
请输入您的选项
3
欢迎使用图书排序功能，正在自动排序
排序后的结果如下，同时排序操作结果已经保存到文档中
[
Book{bookNum=1, bookName='1', writer='1', publish='11', publishDate=BookDate{year=1, month=1, day=1}, remainNum=1, price=1}, 
Book{bookNum=3, bookName='1', writer='3', publish='3', publishDate=BookDate{year=3, month=3, day=3}, remainNum=1, price=3}, 
Book{bookNum=3, bookName='3', writer='33', publish='3', publishDate=BookDate{year=3, month=3, day=33}, remainNum=3, price=3}, 
Book{bookNum=5, bookName='5', writer='5', publish='5', publishDate=BookDate{year=5, month=5, day=5}, remainNum=5, price=5}]
排序操作完毕
1
2
3
4
5
6
7
8
9
10
11
12

再来看看文本里面是啥样的

排序后的结果也被写在了这里
排序方法展示完成

5.修改方法-change（）方法

跟排序方法类似，修改后的结果也会被打印在控制台和文本里面，只不过这次我在文本里面一次展示修改后的全部图书信息，因为我觉得有种可能是我们一次修改好几本书，全部显示这样就可以都展示了（代码太长了emmm）如下：

public void change() throws Exception {
                FileInputStream fil=new FileInputStream("src/BOOK/BookShelf");
                byte[] by=new byte[1000];
                int size= fil.available();
                if(size==0){
                    System.out.println("图书馆暂时没有任何图书信息");
                }else{
                    ObjectInputStream ois=new ObjectInputStream(new FileInputStream("src/BOOK/BookShelf1"));
                    Object o=ois.readObject();
                    ArrayList<Book>books1=(ArrayList<Book>) o;
                    ois.close();
                    System.out.println("欢迎使用图书修改功能，请选择修改方式");
                    System.out.println("请按照以下两种方式进行修改");
                    System.out.println("1:书号   2：书名");
                    Scanner scanner=new Scanner(System.in);
                    int a= scanner.nextInt();
                    if(a==1){
                        System.out.println("请输入书号");
                        int aa=scanner.nextInt();
                        for(Book book:books1){
                            if(book.getBookNum()==aa){
                                System.out.println("请输入你要修改的内容");
                                System.out.println("1:书号  2：书名 3：作者 4：出版社 5：出版日期 6：存馆数量 7：定价");
                                int aaa=scanner.nextInt();
                                switch (aaa){
                                    case 1:
                                        System.out.println("请输入修改后的书号");
                                        int num=scanner.nextInt();
                                        book.setBookNum(num);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    case 2:
                                        System.out.println("请输入修改后的书名");
                                        String name=scanner.next();
                                        book.setBookName(name);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    case 3:
                                        System.out.println("请输入修改后的作者");
                                        String writer=scanner.next();
                                        book.setWriter(writer);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    case 4:
                                        System.out.println("请输入修改后的出版社");
                                        String publish=scanner.next();
                                        book.setPublish(publish);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    case 5:
                                        System.out.println("请输入修改后的出版日期");
                                        System.out.println("请输入具体年份");int year=scanner.nextInt();
                                        System.out.println("请输入当年的具体月份");int month=scanner.nextInt();
                                        System.out.println("请输入当月具体哪一天");int day=scanner.nextInt();
                                        BookDate bookDate=new BookDate(year,month,day);
                                        book.setPublishDate(bookDate);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    case 6:
                                        System.out.println("请输入修改后的存馆数量");
                                        int remainNum=scanner.nextInt();
                                        book.setRemainNum(remainNum);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    case 7:
                                        System.out.println("请输入修改后的定价");
                                        int price=scanner.nextInt();
                                        book.setPrice(price);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    default:
                                        System.out.println("输入错误，没有这个选项！");
                                }
                                break;
                            }
                        }
                        BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/BOOK/BookShelf",true)));
                        bufferedWriter.write("修改后的全部图书信息如下");
                        bufferedWriter.newLine();
                        bufferedWriter.write(String.valueOf(books1));
                        bufferedWriter.newLine();
                        bufferedWriter.flush();;
                        bufferedWriter.close();
                        System.out.println("修改操作完毕！");
                    }
                    if(a==2){
                        System.out.println("请输入书名");
                        String name=scanner.next();
                        for(Book book:books1){
                            if(book.getBookName().equals(name)){
                                System.out.println("请输入你要修改的内容");
                                System.out.println("1:书号  2：书名 3：作者 4：出版社 5：出版日期 6：存馆数量 7：定价");
                                int aaa=scanner.nextInt();
                                switch (aaa){
                                    case 1:
                                        System.out.println("请输入修改后的书号");
                                        int num=scanner.nextInt();
                                        book.setBookNum(num);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    case 2:
                                        System.out.println("请输入修改后的书名");
                                        String bookname=scanner.next();
                                        book.setBookName(bookname);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    case 3:
                                        System.out.println("请输入修改后的作者");
                                        String writer=scanner.next();
                                        book.setWriter(writer);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是是");
                                        System.out.println(book);
                                        break;
                                    case 4:
                                        System.out.println("请输入修改后的出版社");
                                        String publish=scanner.next();
                                        book.setPublish(publish);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    case 5:
                                        System.out.println("请输入修改后的出版日期");
                                        System.out.println("请输入具体年份");int year=scanner.nextInt();
                                        System.out.println("请输入当年的具体月份");int month=scanner.nextInt();
                                        System.out.println("请输入当月具体哪一天");int day=scanner.nextInt();
                                        BookDate bookDate=new BookDate(year,month,day);
                                        book.setPublishDate(bookDate);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    case 6:
                                        System.out.println("请输入修改后的存馆数量");
                                        int remainNum=scanner.nextInt();
                                        book.setRemainNum(remainNum);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    case 7:
                                        System.out.println("请输入修改后的定价");
                                        int price=scanner.nextInt();
                                        book.setPrice(price);
                                        System.out.println("修改成功");
                                        System.out.println("修改后的图书信息是");
                                        System.out.println(book);
                                        break;
                                    default:
                                        System.out.println("输入错误，没有这个选项！");
                                }
                                break;
                            }
                        }
                        BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/BOOK/BookShelf",true)));
                        bufferedWriter.write("修改后的全部图书信息如下");
                        bufferedWriter.newLine();
                        bufferedWriter.write(String.valueOf(books1));
                        bufferedWriter.newLine();
                        bufferedWriter.flush();;
                        bufferedWriter.close();
                        System.out.println("修改操作完毕！");

                    }
                    if(a!=1&&a!=2){
                        System.out.println("输入错误！");
                    }
                    ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("src/BOOK/BookShelf1"));
                    oos.writeObject(books1);
                    oos.flush();
                    oos.close();
                }
                }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192

下面展示一下修改结果，先来控制台

欢迎来到图书板块，请选择您要进行的操作
1:添加图书	2:查询图书	3:图书排序	4:图书修改	5:图书删除
请输入您的选项
4
欢迎使用图书修改功能，请选择修改方式
请按照以下两种方式进行修改
1:书号   2：书名
1
请输入书号
1
请输入你要修改的内容
1:书号  2：书名 3：作者 4：出版社 5：出版日期 6：存馆数量 7：定价
1
请输入修改后的书号
11111
修改成功
修改后的图书信息是

Book{bookNum=11111, bookName='1', writer='1', publish='11', publishDate=BookDate{year=1, month=1, day=1}, remainNum=1, price=1}
修改操作完毕！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

再来看文本，我这里把书号是1的书的书号改成了11111，来看文本：

可以看到画圈的地方已经修改成功了
修改方法展示完毕

6.删除方法-delete（）方法

删除后的结果不会在控制台展示，但是如果确实有那本书的话，再删除，会告诉我们删除成功，同时在文本里面打印剩下的书，代码如下：

public void delete() throws Exception {
                    FileInputStream fil=new FileInputStream("src/BOOK/BookShelf");
                    byte[] by=new byte[1000];
                    int size= fil.available();
                    if(size==0){
                        System.out.println("图书馆暂时没有任何图书信息");
                    }else{
                        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("src/BOOK/BookShelf1"));
                        Object o=ois.readObject();
                        ArrayList<Book>books1=(ArrayList<Book>) o;
                        ois.close();
                        System.out.println("欢迎使用图书删除功能");
                        int num=0;//计数
                        System.out.println("请选择按照以下哪种方式删除图书");
                        System.out.println("1: 书号   2：书名");
                        Scanner scanner=new Scanner(System.in);
                        int a=scanner.nextInt();
                        switch (a){
                            case 1:
                                System.out.println("请输入书号");
                                int aa=scanner.nextInt();
                                for(Book book:books1){
                                    num++;
                                    if(book.getBookNum()==aa){
                                        books1.remove(num-1);
                                        System.out.println("删除成功");break;//实现删除，然后break跳出
                                    }
                                }
                                System.out.println("删除后的结果已经保存到文档中");
                                BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/BOOK/BookShelf",true)));
                                bufferedWriter.write("删除后的结果如下");
                                bufferedWriter.newLine();
                                bufferedWriter.write(String.valueOf(books1));
                                bufferedWriter.newLine();
                                bufferedWriter.flush();;
                                bufferedWriter.close();
                                System.out.println("图书删除功能完毕");
                                break;
                            case 2:
                                System.out.println("请输入书名");
                                String name=scanner.next();
                                for(Book book:books1){
                                    num++;
                                    if(book.getBookName().equals(name)){
                                        books1.remove(num-1);
                                        System.out.println("删除成功");break;//实现删除，然后break跳出
                                    }
                                }
                                System.out.println("删除后的结果已经保存到文档中");
                                BufferedWriter bufferedWriter1=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/BOOK/BookShelf",true)));
                                bufferedWriter1.write("删除后的结果如下");
                                bufferedWriter1.newLine();
                                bufferedWriter1.write(String.valueOf(books1));
                                bufferedWriter1.newLine();
                                bufferedWriter1.flush();;
                                bufferedWriter1.close();
                                System.out.println("图书删除功能完毕");
                                break;
                            default:
                                System.out.println("输入错误！");
                        }
                        if(a!=1&&a!=2){
                            System.out.println("输入错误！");
                        }
                        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("src/BOOK/BookShelf1"));
                        oos.writeObject(books1);
                        oos.flush();
                        oos.close();
                    }
                }
            }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

我们删除一下11111号书
先来看控制台：

欢迎来到图书板块，请选择您要进行的操作
1:添加图书	2:查询图书	3:图书排序	4:图书修改	5:图书删除
请输入您的选项
5
欢迎使用图书删除功能
请选择按照以下哪种方式删除图书
1: 书号   2：书名
1
请输入书号
11111
删除成功
删除后的结果已经保存到文档中
图书删除功能完毕
1
2
3
4
5
6
7
8
9
10
11
12
13

告诉我们删除成功，再来看文本里面剩余的书：

可以看到在上一步测试修改的时候我们还有四本书，现在只打印剩下的三本了
删除功能展示完毕
以上就是BOOK包的全部

三丶PERSON包

因为模式跟BOOK包一模一样，我这里只展示他查重学号的代码，代码还是添加方法的全部，但是我标记出了查重的部分（有备注），还是比较好找的emm，麻烦了

public void add() throws Exception {
        FileInputStream fil = new FileInputStream("src/PERSON/sheet1");
        byte[] by = new byte[1000];
        int size = fil.available();
        if (size == 0) {
            System.out.println("欢迎使用读者添加功能！");
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入添加读者的学号");
            int stunumber = scanner.nextInt();
            ArrayList arrayList = new ArrayList();//新建一个ArrayList数组
            for (Person person : people1) {//在这里用增强for遍历，把目前所有的学号放到新建好的arraylist数组里面
                arrayList.add(person.getStunumber());
            }
            if (arrayList.contains(stunumber)) {
                System.out.println("该读者已经存在，不能创建学号相同的读者");//用ArrayList中的contains方法判断新的学号是否已经存在，存在的话，跳出循环，不存在添加，实现查重
            } else {
                System.out.println("请输入添加读者的名字");
                String name = scanner.next();
                System.out.println("请输入添加读者的学院");
                String college = scanner.next();
                System.out.println("请输入添加读者的专业");
                String major = scanner.next();
                System.out.println("请输入添加读者的班级");
                String group = scanner.next();
                Person person = new Person(stunumber, name, college, major, group);
                System.out.println("添加读者成功！");
                people1.add(person);
                peopleNum++;
                BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/PERSON/Sheet", true)));
                System.out.println("您添加了一名新读者,信息如下，同时信息已保存到文档中");
                System.out.println(person);
                bufferedWriter.write("您添加了一名新读者，信息如下");
                bufferedWriter.newLine();
                bufferedWriter.write(String.valueOf(person));
                bufferedWriter.newLine();
                bufferedWriter.flush();
                bufferedWriter.close();
                System.out.println("读者添加成功");
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/PERSON/Sheet1"));
                oos.writeObject(people1);
                oos.flush();
                oos.close();
            }
        } else {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/PERSON/Sheet1"));
            Object o = ois.readObject();
            ArrayList<Person> people2 = (ArrayList) o;
            ois.close();
            FileWriter fileWriter = new FileWriter(new File("src/PERSON/Sheet1"));
            fileWriter.write("");
            fileWriter.flush();
            fileWriter.close();
            System.out.println("欢迎使用读者添加功能！");
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入添加读者的学号");
            int stunumber = scanner.nextInt();
            ArrayList arrayList = new ArrayList();//新建一个ArrayList数组
            for (Person person : people2) {//在这里用增强for遍历，把目前所有的学号放到新建好的arraylist数组里面
                arrayList.add(person.getStunumber());
            }
            if (arrayList.contains(stunumber)) {
                System.out.println("该读者已经存在，不能创建学号相同的读者");//用ArrayList中的contains方法判断新的学号是否已经存在，存在的话，跳出循环，不存在添加，实现查重
            } else {
                System.out.println("请输入添加读者的名字");
                String name = scanner.next();
                System.out.println("请输入添加读者的学院");
                String college = scanner.next();
                System.out.println("请输入添加读者的专业");
                String major = scanner.next();
                System.out.println("请输入添加读者的班级");
                String group = scanner.next();
                Person person = new Person(stunumber, name, college, major, group);
                System.out.println("添加读者成功！");
                people1.add(person);
                people2.add(person);
                peopleNum++;
                BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/PERSON/Sheet", true)));
                System.out.println("您添加了一名新读者,信息如下，同时读者信息已保存到文档中");
                System.out.println(person);
                bufferedWriter.write("您添加了一名新读者，信息如下");
                bufferedWriter.newLine();
                bufferedWriter.write(String.valueOf(person));
                bufferedWriter.newLine();
                bufferedWriter.flush();
                bufferedWriter.close();
                System.out.println("读者添加成功");
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/PERSON/Sheet1"));
                oos.writeObject(people2);
                oos.flush();
                oos.close();
            }

        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

这里我们添加一名新读者
把他的学号设成5，然后再设一个学号为5,的读者，控制台会告诉我们不能创建学号相同的读者，展示结果如下

欢迎使用图书管理系统
请选择你要进入的板块
1:图书板块	2:读者板块	3:图书借阅板块
请输入您的选项
2
欢迎来到读者板块，请选择您要进行的操作
1:添加读者	2:查询读者	3:读者排序	4:读者修改	5:读者删除
请输入您的选项
1
欢迎使用读者添加功能！
请输入添加读者的学号
5
请输入添加读者的名字
5
请输入添加读者的学院
5
请输入添加读者的专业
5
请输入添加读者的班级
5
添加读者成功！
您添加了一名新读者,信息如下，同时读者信息已保存到文档中

Person{stunumber=5, name='5', college='5', major='5', group='5'}
读者添加成功
请选择是否退出图书管理系统
按3退出	按其他则会继续使用
1
欢迎使用图书管理系统
请选择你要进入的板块
1:图书板块	2:读者板块	3:图书借阅板块
请输入您的选项
2
欢迎来到读者板块，请选择您要进行的操作
1:添加读者	2:查询读者	3:读者排序	4:读者修改	5:读者删除
请输入您的选项
1
欢迎使用读者添加功能！
请输入添加读者的学号
5
该读者已经存在，不能创建学号相同的读者//在这里告诉我们不能重复添加！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

ok，我们看下一个包

四丶Borrow_Back包

这个类主要是记录借书人和还书人的信息的，模式跟上面两个包基本一样
但是代码功能多了点新东西

1丶Borrower类

这个类主要是创建借书者信息的，初始化时候会把还书时期设置为null（因为并没有还书），还有借书日期，应该还日期等等，用了第三代日期的方法，因为我发现第三代日期比较方便嘻嘻

package Borrow_Back;

import BOOK.Book;
import PERSON.Person;

import java.io.Serializable;
import java.time.LocalDateTime;

public class Borrower implements Serializable {
    Person Lender;
    Book LendBook;
    LocalDateTime lenddate = LocalDateTime.now();
    LocalDateTime lastdate = lenddate.plusDays(50);//用localDateTime里面的plusDays方法设置还书期限为五十天，得到最后期限
    String  backdate;//把还书期限设置为String类，这样还书的时候就可以把当时的日期转换为字符串，规定格式，用set.lastdate（）赋值给它

    public Borrower(Person lender, Book lendBook, LocalDateTime lenddate, LocalDateTime lastdate, String backdate) {
        Lender = lender;
        LendBook = lendBook;
        this.lenddate = lenddate;
        this.lastdate = lastdate;
        this.backdate = backdate;
    }

    public Person getLender() {
        return Lender;
    }

    public void setLender(Person lender) {
        Lender = lender;
    }

    public Book getLendBook() {
        return LendBook;
    }

    public void setLendBook(Book lendBook) {
        LendBook = lendBook;
    }

    public LocalDateTime getLenddate() {
        return lenddate;
    }

    public void setLenddate(LocalDateTime lenddate) {
        this.lenddate = lenddate;
    }

    public LocalDateTime getLastdate() {
        return lastdate;
    }

    public void setLastdate(LocalDateTime lastdate) {
        this.lastdate = lastdate;
    }

    public String getBackdate() {
        return backdate;
    }

    public void setBackdate(String backdate) {
        this.backdate = backdate;
    }

    @Override
    public String toString() {
        return "\nBorrower{" +
                "Lender=" + Lender +
                ", LendBook=" + LendBook +
                ", lenddate=" + lenddate +
                ", lastdate=" + lastdate +
                ", backdate='" + backdate + '\'' +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

2丶BorrowList类

该类实现了图书借阅板块的三个功能，借阅者登记，查询借阅信息，图书归还登记，我写的代码可以防止无限借书和无限还书（如果要借的书数量为0，不能借出），除非有人还书，书的数量+1，才能再借给别人，还书的时候会登记上还书时间（emmm自我感觉还是比较有成就感的，虽然很菜哈哈哈），下面看第一个方法：

1.借阅登记-borrow（）方法

public void borrow() throws Exception {
            FileInputStream fil=new FileInputStream("src/Borrow_Back/borrowList1");
            byte[] by=new byte[1000];
            int size= fil.available();
            if(size==0){
                System.out.println("欢迎使用图书借阅登记功能");
                System.out.println("请先输入你的学号");
                Scanner scanner=new Scanner(System.in);
                int stunumber=scanner.nextInt();
                ObjectInputStream ois=new ObjectInputStream(new FileInputStream("src/BOOK/BookShelf1"));
                Object o=ois.readObject();
                ArrayList<Book> books1=(ArrayList) o;
                ois.close();
                ObjectInputStream ojs = new ObjectInputStream(new FileInputStream("src/PERSON/Sheet1"));
                Object oo = ojs.readObject();
                ArrayList<Person> people1 = (ArrayList) oo;
                ojs.close();
                for(Person person:people1){
                    if(person.getStunumber()==stunumber){
                        System.out.println("欢迎使用图书借阅系统  "+person.getName()+"同学");
                        System.out.println("请输入你要借阅的图书的书号");
                        int booknumber=scanner.nextInt();
                        for (Book book:books1){
                            if(book.getBookNum()==booknumber){
                                if(book.getRemainNum()>0){
                                    System.out.println("借阅成功！");
                                    book.setRemainNum(book.getRemainNum()-1);
                                    LocalDateTime lenddate = LocalDateTime.now();
                                    LocalDateTime lastdate = lenddate.plusDays(50);
                                    Borrower borrower=new Borrower(person,book,lenddate,lastdate,null);
                                    borrowers.add(borrower);
                                    System.out.println("该本图书的剩余数量为"+book.getRemainNum());
                                    BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/Borrow_Back/borrowList",true)));
                                    System.out.println("您添加了一名借阅者,信息如下，同时信息已保存到文档中");
                                    System.out.println(borrowers);
                                    bufferedWriter.write("您添加了一名借阅者，信息如下");
                                    bufferedWriter.newLine();
                                    bufferedWriter.write(String.valueOf(borrowers));
                                    bufferedWriter.newLine();
                                    bufferedWriter.flush();;
                                    bufferedWriter.close();
                                    System.out.println("借阅信息登记成功！");
                                    break;
                                }else {
                                    System.out.println("抱歉，图书馆里这本书的剩余数量为零");//数量为0不能借出
                                }
                            }
                        }break;
                    }
                }
                ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("src/Borrow_Back/borrowList1"));
                oos.writeObject(borrowers);
                oos.flush();
                oos.close();
                ObjectOutputStream ops=new ObjectOutputStream(new FileOutputStream("src/BOOK/BookShelf1"));
                ops.writeObject(books1);
                ops.flush();
                ops.close();
                ObjectOutputStream oqs = new ObjectOutputStream(new FileOutputStream("src/PERSON/Sheet1"));
                oqs.writeObject(people1);
                oqs.flush();
                oqs.close();
                System.out.println("图书借阅登记功能完毕");
            }else{
                System.out.println("欢迎使用图书借阅登记功能");
                System.out.println("请先输入你的学号");
                Scanner scanner=new Scanner(System.in);
                int stunumber=scanner.nextInt();
                ObjectInputStream oks=new ObjectInputStream(new FileInputStream("src/Borrow_Back/borrowList1"));
                Object ooo=oks.readObject();
                ArrayList<Borrower>borrowers1=(ArrayList<Borrower>) ooo;
                oks.close();
                ObjectInputStream ois=new ObjectInputStream(new FileInputStream("src/BOOK/BookShelf1"));
                Object o=ois.readObject();
                ArrayList<Book> books1=(ArrayList) o;
                ois.close();
                ObjectInputStream ojs = new ObjectInputStream(new FileInputStream("src/PERSON/Sheet1"));
                Object oo = ojs.readObject();
                ArrayList<Person> people1 = (ArrayList) oo;
                ojs.close();
                FileWriter fileWriter=new FileWriter(new File("src/Borrow_Back/borrowList1"));
                fileWriter.write("");
                fileWriter.flush();
                fileWriter.close();//清除原来的数据
                for(Person person:people1){
                    if(person.getStunumber()==stunumber){
                        System.out.println("欢迎使用图书借阅系统  "+person.getName()+"同学");
                        System.out.println("请输入你要借阅的图书的书号");
                        int booknumber=scanner.nextInt();
                        for (Book book:books1){
                            if(book.getBookNum()==booknumber){
                                if(book.getRemainNum()>0){
                                    System.out.println("借阅成功！");
                                    book.setRemainNum(book.getRemainNum()-1);
                                    LocalDateTime lenddate = LocalDateTime.now();
                                    LocalDateTime lastdate = lenddate.plusDays(50);
                                    Borrower borrower=new Borrower(person,book,lenddate,lastdate,null);
                                    borrowers.add(borrower);
                                    borrowers1.add(borrower);
                                    System.out.println("该本图书的剩余数量为"+book.getRemainNum());
                                    BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/Borrow_Back/borrowList",true)));
                                    System.out.println("您添加了一名借阅者,信息如下，同时信息已保存到文档中");
                                    System.out.println(borrower);
                                    bufferedWriter.write("您添加了一名借阅者，信息如下");
                                    bufferedWriter.newLine();
                                    bufferedWriter.write(String.valueOf(borrower));
                                    bufferedWriter.newLine();
                                    bufferedWriter.flush();;
                                    bufferedWriter.close();
                                    System.out.println("借阅信息添加成功！");
                                    break;
                                }else {
                                    System.out.println("抱歉，图书馆里这本书的剩余数量为零");//数量为0不能借出
                                }
                            }
                        }
                        break;
                    }
                }
                ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("src/Borrow_Back/borrowList1"));
                oos.writeObject(borrowers1);
                oos.flush();
                oos.close();
                ObjectOutputStream ops=new ObjectOutputStream(new FileOutputStream("src/BOOK/BookShelf1"));
                ops.writeObject(books1);
                ops.flush();
                ops.close();
                ObjectOutputStream oqs = new ObjectOutputStream(new FileOutputStream("src/PERSON/Sheet1"));
                oqs.writeObject(people1);
                oqs.flush();
                oqs.close();
                System.out.println("图书借阅登记功能完毕");
            }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

其实和之前两个包里面的添加功能差不多，同样会把借阅者的信息打印在控制台和文本里面，展示一下：
先看控制台，代码如下：

欢迎来到图书借阅板块，请选择您要进行的操作
1:图书借阅信息登记	2:图书归还信息登记	3:图书借阅信息查询
请输入您的选项
1
欢迎使用图书借阅登记功能
请先输入你的学号
5
欢迎使用图书借阅系统  5同学
请输入你要借阅的图书的书号
3
借阅成功！
该本图书的剩余数量为0
您添加了一名借阅者,信息如下，同时信息已保存到文档中

Borrower{Lender=
Person{stunumber=5, name='5', college='5', major='5', group='5'}, LendBook=
Book{bookNum=3, bookName='1', writer='3', publish='3', publishDate=BookDate{year=3, month=3, day=3}, remainNum=0, price=3}, lenddate=2022-05-24T14:34:58.017, lastdate=2022-07-13T14:34:58.017, backdate='null'}
借阅信息添加成功！
图书借阅登记功能完毕
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

再来看文本里面

太长了图片展示不完hhh，但是还书日期都是null，得还书以后才会添加上还书的日期！，我这里改写了以下，用对象处理流把借的书的数量减少1，再把改完的数组写入原本的放书的文本里面（BookShelf1），这样书的剩余数量就会减少1了，如果书的数量为零时候，系统会提示我们书的数量为零，不能借了。结果演示代码如下

欢迎来到图书借阅板块，请选择您要进行的操作
1:图书借阅信息登记	2:图书归还信息登记	3:图书借阅信息查询
请输入您的选项
1
欢迎使用图书借阅登记功能
请先输入你的学号
5
欢迎使用图书借阅系统  5同学
请输入你要借阅的图书的书号
3
抱歉，图书馆里这本书的剩余数量为零
图书借阅登记功能完毕
1
2
3
4
5
6
7
8
9
10
11
12

2.查询-seek（）方法

这个方法就是普通的查询，没啥好说的，跟book里面的差不多，特点就是还书以后，同一个借阅信息的还书日期会被打上当时的日期，我再比较一下结果，代码如下：

 public void seek() throws Exception {
        FileInputStream fil=new FileInputStream("src/Borrow_Back/borrowList1");
        byte[] by=new byte[1000];
        int size= fil.available();
        if(size==0){
            System.out.println("暂时没有任何借阅信息");
        }else {
            System.out.println("欢迎使用借阅信息查询功能");
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/Borrow_Back/borrowList1"));
            Object o = ois.readObject();
            ArrayList<Borrower> borrowers1 = (ArrayList) o;
            ois.close();
            System.out.println("请选择以下三种查询方式中的一种");
            System.out.println("1:学号\t2:书名\n3：学院");
            System.out.println("请输入您的选项");
            Scanner scanner = new Scanner(System.in);
            int c = scanner.nextInt();
            switch (c) {
                case 1:
                    System.out.println("请输入学号");
                    int stunumber = scanner.nextInt();
                    for (Borrower borrower : borrowers1) {
                        if (borrower.getLender().getStunumber() == stunumber) {
                            System.out.println(borrower);
                        }
                    }
                    break;
                case 2:
                    System.out.println("请输入书名");
                    String bookname = scanner.next();
                    for (Borrower borrower : borrowers1) {
                        if (borrower.getLendBook().getBookName().equals(bookname)) {
                            System.out.println(borrower);
                        }
                    }
                    break;
                case 3:
                    System.out.println("请输入你要查找的学院借阅信息");
                    String college = scanner.next();
                    for (Borrower borrower : borrowers1) {
                        if (borrower.getLender().getCollege().equals(college)) {
                            System.out.println(borrower);
                        }
                    }
                    break;
                default:
                    System.out.println("输入错误！请重新输入");
            }
            System.out.println("借阅信息查询功能完毕");
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

只借不还时候，查询结果如下：

欢迎来到图书借阅板块，请选择您要进行的操作
1:图书借阅信息登记	2:图书归还信息登记	3:图书借阅信息查询
请输入您的选项
3
欢迎使用借阅信息查询功能
请选择以下三种查询方式中的一种
1:学号	2:书名
3：学院
请输入您的选项
1
请输入学号
5

Borrower{Lender=
Person{stunumber=5, name='5', college='5', major='5', group='5'}, LendBook=
Book{bookNum=3, bookName='1', writer='3', publish='3', publishDate=BookDate{year=3, month=3, day=3}, remainNum=0, price=3}, lenddate=2022-05-24T14:34:58.017, lastdate=2022-07-13T14:34:58.017, backdate='null'}
借阅信息查询功能完毕
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

我们可以看到backdate=null；当我们还书以后，backdate就会被打上当时的时间；

欢迎使用图书归还功能
请先输入你的学号
5
请输入你要归还的图书的书号
3
归还成功！
该本书剩余的数量为1
您添加了一名归还者,信息如下，同时信息已保存到文档中

Borrower{Lender=
Person{stunumber=5, name='5', college='5', major='5', group='5'}, LendBook=
Book{bookNum=3, bookName='1', writer='3', publish='3', publishDate=BookDate{year=3, month=3, day=3}, remainNum=0, price=3}, lenddate=2022-05-24T14:34:58.017, lastdate=2022-07-13T14:34:58.017, backdate='2022年05月24日 14小时45分34秒'}
图书归还完毕
1
2
3
4
5
6
7
8
9
10
11
12
13

如上所示

3.归还-back（）方法

在查询方法里面我已经展示了归还后再查询控制台会显示的信息（就是新增一个还书日期-backdate），然后我还写了判断一个人时候还完书的东西，因为一个人如果借了两本书的话，他只能还两本书，肯定不能无限还书，让书的数量无限增长；用到了continue关键字，判断backdate是否为null，如果为null，就可以还书，如果不为null，就说明这本书已经还了，没必要还书了，从而控制书的数量≤本来的数量，不让他无限增长，在下面的代码里面标注出来了（在中间部分），方法代码如下：

public void back () throws Exception {

        FileInputStream fil=new FileInputStream("src/Borrow_Back/borrowList1");
        byte[] by=new byte[1000];
        int size= fil.available();
        if(size==0){
            System.out.println("暂时没有任何借阅信息");
        }else{
            System.out.println("欢迎使用图书归还功能");
            System.out.println("请先输入你的学号");
            Scanner scanner=new Scanner(System.in);
            int stunumber=scanner.nextInt();
            ObjectInputStream ois=new ObjectInputStream(new FileInputStream("src/BOOK/BookShelf1"));
            Object o=ois.readObject();
            ArrayList<Book> books1=(ArrayList) o;
            ois.close();
            ObjectInputStream ojs = new ObjectInputStream(new FileInputStream("src/PERSON/Sheet1"));
            Object oo = ojs.readObject();
            ArrayList<Person> people1 = (ArrayList) oo;
            ojs.close();
            ObjectInputStream oks=new ObjectInputStream(new FileInputStream("src/Borrow_Back/borrowList1"));
            Object ooo=oks.readObject();
            ArrayList<Borrower>borrowers1=(ArrayList<Borrower>) ooo;
            oks.close();
            FileWriter fileWriter=new FileWriter(new File("src/Borrow_Back/borrowList1"));
            fileWriter.write("");
            fileWriter.flush();
            fileWriter.close();
            for(Person person:people1){
                if(person.getStunumber()==stunumber){
                    System.out.println("请输入你要归还的图书的书号");
                    int bookNum=scanner.nextInt();
                    for(Book book:books1){
                        if(book.getBookNum()==bookNum){
                            for(Borrower borrower:borrowers1){
                                if(borrower.getLender().getStunumber()==person.getStunumber()&&borrower.getLendBook().getBookNum()==book.getBookNum()){
                                    //双重判断归还者的信息存在且能匹配上读者和图书
                                    if(borrower.getBackdate()!=null){
                                        continue;//如果某个人已经还书了，continue就会跳过本次循环执行下一次循环,这样不会执行下面的代码，不会无限还书
                                    }
                                    DateTimeFormatter dft=DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分ss秒");
                                    LocalDateTime ldt = LocalDateTime.now();
                                    String backtime=ldt.format(dft);
                                    borrower.setBackdate(backtime);
                                    System.out.println("归还成功！");
                                    book.setRemainNum(book.remainNum+1);
                                    System.out.println("该本书剩余的数量为"+book.getRemainNum());
                                    BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/Borrow_Back/borrowList",true)));
                                    System.out.println("您添加了一名归还者,信息如下，同时信息已保存到文档中");
                                    System.out.println(borrower);
                                    bufferedWriter.write("您添加了一名归还者，信息如下");
                                    bufferedWriter.newLine();
                                    bufferedWriter.write(String.valueOf(borrower));
                                    bufferedWriter.newLine();
                                    bufferedWriter.flush();;
                                    bufferedWriter.close();
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("src/Borrow_Back/borrowList1"));
            oos.writeObject(borrowers1);
            oos.flush();
            oos.close();
            ObjectOutputStream ops=new ObjectOutputStream(new FileOutputStream("src/BOOK/BookShelf1"));
            ops.writeObject(books1);
            ops.flush();
            ops.close();
            ObjectOutputStream oqs = new ObjectOutputStream(new FileOutputStream("src/PERSON/Sheet1"));
            oqs.writeObject(people1);
            oqs.flush();
            oqs.close();
            System.out.println("图书归还完毕");
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

五丶SYSTEM1包

该类是系统包，在这两个包里面有两个类

1丶System1类

主要就是起选择调用全部的方法，然后封装在该类的system1方法里面，注意在开头要创建三个类（Book，Person,BorrowList）的三个对象作为成员变量，代码如下：

package SYSTEM1;

import BOOK.BookShelf;
import Borrow_Back.BorrowList;
import PERSON.Sheet;

import java.util.Scanner;

public class System1 {
    BookShelf bookshelf = new BookShelf();
    Sheet sheet = new Sheet();
    BorrowList borrowList=new BorrowList();
    public void system1() throws Exception {

        System.out.println("欢迎使用图书管理系统");
        System.out.println("请选择你要进入的板块");
        System.out.println("1:图书板块\t2:读者板块\t3:图书借阅板块");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的选项");
        int choice = scanner.nextInt();
        if (choice == 1) {
            System.out.println("欢迎来到图书板块，请选择您要进行的操作");
            System.out.println("1:添加图书\t2:查询图书\t3:图书排序\t4:图书修改\t5:图书删除");
            System.out.println("请输入您的选项");
            int choice1 = scanner.nextInt();
            switch (choice1) {
                case 1:
                    bookshelf.add();
                    break;
                case 2:
                    bookshelf.seek();
                    break;
                case 3:
                    bookshelf.sort();
                    break;
                case 4:
                    bookshelf.change();
                    break;
                case 5:
                    bookshelf.delete();
                    break;
                default:
                    System.out.println("输入错误，请重新输入");
            }
        } else if (choice == 2) {
            System.out.println("欢迎来到读者板块，请选择您要进行的操作");
            System.out.println("1:添加读者\t2:查询读者\t3:读者排序\t4:读者修改\t5:读者删除");
            System.out.println("请输入您的选项");
            int choice2 = scanner.nextInt();
            switch (choice2) {
                case 1:
                    sheet.add();
                    break;
                case 2:
                    sheet.seek();
                    break;
                case 3:
                    sheet.sort();
                    break;
                case 4:
                    sheet.change();
                    break;
                case 5:
                    sheet.delete();
                    break;
                default:
                    System.out.println("输入错误，请重新输入");
            }
        } else if (choice == 3) {
            System.out.println("欢迎来到图书借阅板块，请选择您要进行的操作");
            System.out.println("1:图书借阅信息登记\t2:图书归还信息登记\t3:图书借阅信息查询");
            System.out.println("请输入您的选项");
            int choice3 = scanner.nextInt();
            switch (choice3) {
                case 1:
                    borrowList.borrow();
                    break;
                case 2:
                    borrowList.back();
                    break;
                case 3:
                    borrowList.seek();
                    break;
                default:
                    System.out.println("输入错误，请重新输入");
            }
        } else if (choice!=1||choice!=2||choice!=3) {
            System.out.println("输入错误，请重新输入");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

2丶MENU1类

菜单类，最后就运行这个类就行，用了while循环让程序循环起来，按3退出，按其他继续使用

package SYSTEM1;

import java.util.Scanner;

public class MENU1 {
    public static void main(String[] args) throws Exception {
        System1 system01=new System1();
        Scanner scanner=new Scanner(System.in);
        while(true){
            system01.system1();
            System.out.println("请选择是否退出图书管理系统");
            System.out.println("按3退出\t按其他则会继续使用");
            int choice=scanner.nextInt();
            if(choice==3){
                break;
            }else {

            }
        }
    }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

总结

以上就是我的图书馆管理系统作业，通过这个作业，对io印象更深了，因为用了io，关闭程序以后也可以读到之前的信息，写入的信息直接就可以在文本里面看到，觉得还是比较神奇的，谢谢观看