前言

熟悉一下java的基本操作

猜拳游戏

import java.util.Scanner;
// 电脑类
class Computer {
private String computerName; // 电脑名称
private int computerMethod; // 电脑出拳方法
static int winTimes = 0; // 电脑累计赢的次数

// 设置电脑名称
public void setComputerName(int num) {
switch (num) {
case 1:
computerName = "曹操";
break;
case 2:
computerName = "刘备";
break;
case 3:
computerName = "孙权";
break;
}
}

// 获取电脑名称
public String getComputerName() {
return computerName;
}

// 获取电脑出拳方法,随机生成1,2,3
public int getComputerMethod() {
computerMethod = (int) (Math.random() * 3) + 1;
return computerMethod;
}
}

// 玩家类
class Player {
private String playerName; // 玩家姓名
private int playerMethod; // 玩家方法
static int winTimes = 0; // 玩家累计赢的次数

// 获取玩家姓名
public String getPlayerName() {
return playerName;
}

// 设置玩家姓名
public void setPlayerName(String playerName) {
this.playerName = playerName;
}

// 获取玩家出拳方法
public int getPlayerMethod(int num) {
playerMethod = num;
return playerMethod;
}
}

// 游戏平台类
class GamePlatform {
private Computer mComputer; // 电脑实例
private Player mPlayer; // 玩家实例

// 打印欢迎界面
private void beginningShow() {
System.out.println("————————————欢迎进入游戏世界————————————");
System.out.println(" ************************");
System.out.println(" ********猜拳开始*********");
System.out.println(" ************************");
System.out.println("出拳规则:1.石头 2.剪刀 3.布");
}

// 输入玩家姓名,选择对手,然后开始执行游戏
private void gameStart() {
// 创建电脑对象
mComputer = new Computer();
// 创建玩家对象
mPlayer = new Player();
// 创建输入对象
Scanner input = new Scanner(System.in);
// 输入玩家姓名
System.out.print("请输入你的姓名:");
String name = input.next();
mPlayer.setPlayerName(name);
// 选择对手
System.out.print("请选择对手<1-曹操 2-刘备 3-孙权>:");
int num = input.nextInt();
mComputer.setComputerName(num);
// 开始游戏
System.out.println("游戏开始!");
gameProceed();
}

// 游戏双发出拳不断重复的过程
private void gameProceed() {
// 创建输入对象
Scanner input = new Scanner(System.in);
// 创建循环变量
boolean flag = true;
// 循环开始
while (flag) {
// 玩家出拳
System.out.print("请出拳(1.石头 2.剪刀 3.布):");
int playerMethod = input.nextInt();
mPlayer.getPlayerMethod(playerMethod);
// 电脑出拳
int computerMethod = mComputer.getComputerMethod();
// 判断输赢
if (playerMethod == computerMethod ) {
// 平局
System.out.println("平局!");
} else if (playerMethod == 1 && computerMethod == 2
|| playerMethod == 2 && computerMethod == 3
|| playerMethod == 3 && computerMethod == 1) {
// 玩家赢
System.out.println(mPlayer.getPlayerName() +"赢了!");
Player.winTimes++;
} else {
// 电脑赢
System.out.println(mComputer.getComputerName() +"赢了!");
Computer.winTimes++;
}
// 显示双方出拳
System.out.println("你出拳:" + showMethod(playerMethod));
System.out.println(mComputer.getComputerName() + "出拳:" + showMethod(computerMethod));
// 判断是否继续
System.out.println("是否继续?(y/n)");
String choice = input.next();
if (choice.equals("n")) {
// 结束游戏
flag = false;
gameEnd();
}
}
}

// 游戏结束界面、输赢次数统计、判决结果显示
private void gameEnd() {
System.out.println("-----------------结果------------------");
System.out.println(" *** " + mPlayer.getPlayerName() + " : " + mComputer.getComputerName() + " ***");
System.out.println("-----------------比分------------------");
System.out.println(" *** " + Player.winTimes + " : " + Computer.winTimes + " ***");
System.out.println("**************************************");
if (Player.winTimes > Computer.winTimes) {
System.out.println("恭喜你赢了!");
} else if (Player.winTimes < Computer.winTimes) {
System.out.println("很遗憾你输了!");
} else {
System.out.println("旗鼓相当平局!");
}
}

// 将数字转换为石头、剪刀、布
private String showMethod(int num) {
String method = "";
switch (num) {
case 1:
method = "石头";
break;
case 2:
method = "剪刀";
break;
case 3:
method = "布";
break;
}
return method;
}

// 唯一公有接口,调用其它方法,完成整个程序运行
public void algorithmProceed() {
beginningShow();
gameStart();
}
}

// 运行类
public class GuessGame {
public static void main(String[] args) {
// 创建游戏平台对象
GamePlatform game = new GamePlatform();
// 调用游戏平台的方法
game.algorithmProceed();
}
}

职员信息管理系统

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

class Employee implements Serializable {
private static final long serialVersionUID = 1L;
private String id;
private String name;
private String sex;
private String education;
private int age;
private double salary;
private String phone;

public Employee(String id, String name, String sex, String education, int age, double salary, String phone) {
this.id = id;
this.name = name;
this.sex = sex;
this.education = education;
this.age = age;
this.salary = salary;
this.phone = phone;
}

public String getId() {
return id;
}

public String getName() {
return name;
}

public String getSex() {
return sex;
}

public String getEducation() {
return education;
}

public int getAge() {
return age;
}

public double getSalary() {
return salary;
}

public String getPhone() {
return phone;
}

public void setId(String id) {
this.id = id;
}

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

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

public void setEducation(String education) {
this.education = education;
}

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

public void setSalary(double salary) {
this.salary = salary;
}

public void setPhone(String phone) {
this.phone = phone;
}

@Override
public String toString() {
return "工号: " + id + "\n" +
"姓名: " + name + "\n" +
"性别(m或f): " + sex + "\n" +
"学历: " + education + "\n" +
"年龄: " + age + "\n" +
"工资: " + String.format("%.1f", salary) + "\n" +
"电话: " + phone + "\n";
}
}

class EmployeeManager {
private List<Employee> employees = new ArrayList<>();

public void addWorker(Employee employee) {
employees.add(employee);
}

public void deleteWorker(String id) {
for (Employee employee : employees) {
if (employee.getId().equals(id)) {
employees.remove(employee);
break;
}
}
}

public void modification(Employee employee) {
for (Employee e : employees) {
if (e.getId().equals(employee.getId())) {
e.setName(employee.getName());
e.setSex(employee.getSex());
e.setEducation(employee.getEducation());
e.setAge(employee.getAge());
e.setSalary(employee.getSalary());
e.setPhone(employee.getPhone());
break;
}
}
}

public List<Employee> getEmployees() {
return employees;
}

public void sortByIdAsc() {
Collections.sort(employees, new Comparator<Employee>() {
@Override
public int compare(Employee o1, Employee o2) {
return o1.getId().compareTo(o2.getId());
}
});
}

public void sortByIdDesc() {
Collections.sort(employees, new Comparator<Employee>() {
@Override
public int compare(Employee o1, Employee o2) {
return o2.getId().compareTo(o1.getId());
}
});
}

public void sortBySalaryAsc() {
Collections.sort(employees, new Comparator<Employee>() {
@Override
public int compare(Employee o1, Employee o2) {
return Double.compare(o1.getSalary(), o2.getSalary());
}
});
}

public void sortBySalaryDesc() {
Collections.sort(employees, new Comparator<Employee>() {
@Override
public int compare(Employee o1, Employee o2) {
return Double.compare(o2.getSalary(), o1.getSalary());
}
});
}

public Employee findById(String id) {
for (Employee employee : employees) {
if (employee.getId().equals(id)) {
return employee;
}
}
return null;
}

public List<Employee> findByName(String name) {
List<Employee> result = new ArrayList<>();
for (Employee employee : employees) {
if (employee.getName().equals(name)) {
result.add(employee);
}
}
return result;
}

public void writeFile() throws IOException {
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("employees.dat"))) {
oos.writeObject(employees);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public void loadFile() throws IOException, ClassNotFoundException {
try {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("employees.dat"));
employees = (List<Employee>) ois.readObject();
ois.close();
} catch (FileNotFoundException e) {
// 不做任何处理
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}




}








public class Main {
private static Scanner scanner = new Scanner(System.in);
private static EmployeeManager manager = new EmployeeManager();
public static void main(String[] args) throws IOException, ClassNotFoundException {
manager.loadFile();
while (true) {
System.out.println("请选择操作:");
System.out.println("1. 增加人员");
System.out.println("2. 修改人员");
System.out.println("3. 删除人员");
System.out.println("4. 职工信息排序");
System.out.println("5. 职工信息查找");
System.out.println("6. 所有职工信息显示");
System.out.println("7. 职工信息保存");
System.out.println("0. 退出程序");

int choice = scanner.nextInt();
scanner.nextLine();

switch (choice) {
case 1:
addWorker();
break;
case 2:
modification();
break;
case 3:
deleteWorker();
break;
case 4:
sortWorker();
break;
case 5:
findWorker();
break;
case 6:
showWorker();
break;
case 7:
saveEmployees();
break;
case 0:
System.exit(0);
break;
default:
System.out.println("无效的选择,请重新输入。");
break;
}
}
}

private static void addWorker() {
System.out.println("请输入职工信息:");
System.out.print("工号: ");
String id = scanner.nextLine();
System.out.print("姓名: ");
String name = scanner.nextLine();
System.out.print("性别(m或f): ");
String sex = scanner.nextLine();
System.out.print("学历: ");
String education = scanner.nextLine();
System.out.print("年龄: ");
int age = scanner.nextInt();
scanner.nextLine();
System.out.print("工资: ");
double salary = scanner.nextDouble();
scanner.nextLine();
System.out.print("电话: ");
String phone = scanner.nextLine();

Employee employee = new Employee(id, name, sex, education, age, salary, phone);
manager.addWorker(employee);
System.out.println("职工信息已添加。");
}

private static void modification() {
System.out.print("请输入要修改的职工工号: ");
String id = scanner.nextLine();
Employee employee = manager.findById(id);
if (employee == null) {
System.out.println("未找到该职工。");
return;
}
System.out.println("请输入新的职工信息:");
System.out.print("姓名: ");
String name = scanner.nextLine();
System.out.print("性别(m或f): ");
String sex = scanner.nextLine();
System.out.print("学历: ");
String education = scanner.nextLine();
System.out.print("年龄: ");
int age = scanner.nextInt();
scanner.nextLine();
System.out.print("工资: ");
double salary = scanner.nextDouble();
scanner.nextLine();
System.out.print("电话: ");
String phone = scanner.nextLine();

employee.setName(name);
employee.setSex(sex);
employee.setEducation(education);
employee.setAge(age);
employee.setSalary(salary);
employee.setPhone(phone);
manager.modification(employee);
System.out.println("职工信息已更新。");
}

private static void deleteWorker() {
System.out.print("请输入要删除的职工工号: ");
String id = scanner.nextLine();
manager.deleteWorker(id);
System.out.println("职工信息已删除。");
}

private static void sortWorker() {
System.out.println("请选择排序方式:");
System.out.println("1. 按工号升序排序");
System.out.println("2. 按工号降序排序");
System.out.println("3. 按工资升序排序");
System.out.println("4. 按工资降序排序");

int choice = scanner.nextInt();
scanner.nextLine();

switch (choice) {
case 1:
manager.sortByIdAsc();
System.out.println("职工信息已按工号升序排序。");
break;
case 2:
manager.sortByIdDesc();
System.out.println("职工信息已按工号降序排序。");
break;
case 3:
manager.sortBySalaryAsc();
System.out.println("职工信息已按工资升序排序。");
break;
case 4:
manager.sortBySalaryDesc();
System.out.println("职工信息已按工资降序排序。");
break;
default:
System.out.println("无效的选择,请重新输入。");
break;
}
}

private static void findWorker() {
System.out.println("请选择查找方式:");
System.out.println("1. 按工号查找");
System.out.println("2. 按姓名查找");

int choice = scanner.nextInt();
scanner.nextLine();

switch (choice) {
case 1:
System.out.print("请输入要查找的职工工号: ");
String id = scanner.nextLine();
Employee employee = manager.findById(id);
if (employee == null) {
System.out.println("未找到该职工。");
} else {
System.out.println(employee);
}
break;
case 2:
System.out.print("请输入要查找的职工姓名: ");
String name = scanner.nextLine();
List<Employee> employees = manager.findByName(name);
if (employees.isEmpty()) {
System.out.println("未找到该职工。");
} else {
for (Employee e : employees) {
System.out.println(e);
}
}
break;
default:
System.out.println("无效的选择,请重新输入。");
break;
}
}

private static void showWorker() {
List<Employee> employees = manager.getEmployees();
if (employees.isEmpty()) {
System.out.println("没有职工信息。");
} else {
for (Employee employee : employees) {
System.out.println(employee);
}
}
}

private static void saveEmployees() {
try {
manager.writeFile();
System.out.println("职工信息已保存");
} catch (IOException e) {
System.out.println("保存职工信息失败: " + e.getMessage());
}
}






}


图书管理系统

Book.java

package com.book;

import java.io.Serializable;

import java.util.Scanner;



public class Book implements Serializable, Comparable<Book> {

/**

*

*/

private static final long serialVersionUID = 1L;

private String bookId; // 书籍ID

private String bookName; // 书籍名称

private String bookAuthor; // 书籍作者

private double bookPrice; // 书籍价格

private String bookISBN; // 书籍ISBN号

private String bookType; // 书籍类型

private boolean bookState; // 书籍状态,true表示可借,false表示不可借

private transient Scanner sc = new Scanner(System.in); // 扫描器对象



public void inputBook() {

System.out.println("请输入书籍名称:");

bookName = sc.next();

System.out.println("请输入书籍作者:");

bookAuthor = sc.next();

System.out.println("请输入书籍价格:");

bookPrice = sc.nextDouble();

System.out.println("请输入书籍ISBN号:");

bookISBN = sc.next();

System.out.println("请输入书籍类型:");

bookType = sc.next();

System.out.println("请输入书籍状态(true或false):");

bookState = sc.nextBoolean();

bookId = BookManager.getBookIdAutoIncrease(); // 调用BookManager类的静态方法生成自动编号的ID

}



void outputBook() {

System.out.println("ID: " + bookId);

System.out.println("名称: " + bookName);

System.out.println("作者: " + bookAuthor);

System.out.println("价格: " + bookPrice);

System.out.println("ISBN号: " + bookISBN);

System.out.println("类型: " + bookType);

System.out.println("状态: " + (bookState ? "可借" : "不可借"));

}



public String getBookId() {

return bookId;

}



public void setBookId(String bookId) {

this.bookId = bookId;

}



public String getBookName() {

return bookName;

}



public void setBookName(String bookName) {

this.bookName = bookName;

}





public String getBookAuthor () {

return bookAuthor;

}



public void setBookAuthor (String bookAuthor) {

this.bookAuthor = bookAuthor;

}



public double getBookPrice () {

return bookPrice;

}



public void setBookPrice (double bookPrice) {

this.bookPrice = bookPrice;

}



public String getBookISBN () {

return bookISBN;

}



public void setBookISBN (String bookISBN) {

this.bookISBN = bookISBN;

}



public String getBookType () {

return bookType;

}



public void setBookType (String bookType) {

this.bookType = bookType;

}



public boolean isBookState () {

return bookState;

}



public void setBookState (boolean bookState) {

this.bookState = bookState;

}



@Override

public int compareTo(Book other) { // 按照ID升序排序

return this.bookId.compareTo(other.bookId);

}



// 添加一个public的setter方法,用来设置sc的值

public void setSc(Scanner sc) {

this.sc = sc;

}

}


BookManager.java

package com.book;

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;



public class BookManager {

private List<Book> bookList = null; // 存储所有书籍对象的列表

private static int bookIDAuto = 1; // 书籍ID自动编号



public static String getBookIdAutoIncrease() { // 生成自动编号的书籍ID

return "BK" + String.format("%06d", bookIDAuto++);

}



public BookManager() { // 构造方法,初始化书籍列表为空的ArrayList

bookList = new ArrayList<>();

}



public void addBook(Book book) { // 添加一个书籍对象到列表中

if (book != null) {

bookList.add(book);

System.out.println("添加成功");

} else {

System.out.println("添加失败");

}

}



public void removeBook(String bookId) { // 根据书籍ID删除一个书籍对象

Book book = getBook(bookId); // 查找要删除的书籍对象

if (book != null) {

bookList.remove(book); // 从列表中删除

System.out.println("删除成功");

} else {

System.out.println("删除失败");

}

}



public void updateBook(String bookId) { // 根据书籍ID修改一个书籍对象的信息

Book book = getBook(bookId); // 查找要修改的书籍对象

if (book != null) {

book.inputBook(); // 输入新的信息并赋值给属性

System.out.println("修改成功");

} else {

System.out.println("修改失败");

}

}



public Book getBook(String bookId) { // 根据书籍ID查找并返回一个书籍对象

for (Book b : bookList) { // 遍历列表中的每个书籍对象

if (b.getBookId().equals(bookId)) { // 如果ID匹配,则返回该对象

return b;

}

}

return null; // 如果没有找到,则返回null

}



public List<Book> getAllBooks() { // 返回所有书籍对象的列表

return bookList;

}



public void outputAllBooks() { // 输出所有书籍对象的信息

for (Book b : bookList) {

System.out.println("---------------------------");

b.outputBook();

}

}



public List<Book> getBooksByName(String name) { // 根据书籍名称模糊查询并返回一个列表

List<Book> books = new ArrayList<>(); // 创建一个空的列表

for (Book b : bookList) { // 遍历所有书籍对象

if (b.getBookName().contains(name)) { // 如果名称包含查询关键字,则添加到列表中

books.add(b);

}

}

return books; // 返回列表

}



public List<Book> getBooksByISBN(String isbn) { // 根据ISBN号查询并返回一个列表

List<Book> books = new ArrayList<>(); // 创建一个空的列表

for (Book b : bookList) { // 遍历所有书籍对象

if (b.getBookISBN().equals(isbn)) { // 如果ISBN号匹配,则添加到列表中

books.add(b);

}

}

return books; // 返回列表

}



public void saveToFile() { // 将所有书籍对象保存到文件中

DataIO.saveObjectToFile(bookList, "books.dat"); // 调用DataIO类的静态方法将列表保存到文件中

}



public void loadFromFile() { // 从文件中加载所有书籍对象到列表中

Object obj = DataIO.readObjectFromFile("books.dat"); // 调用DataIO类的静态方法从文件中加载对象

if (obj instanceof List<?>) { // 判断是否是列表类型

List<?> list = (List<?>) obj;

if (!list.isEmpty()) {

Object firstObj = list.get(0);

if (firstObj instanceof Book) {

this.bookList = (List<Book>) list;

for (Book b : bookList) {

b.setSc(new Scanner(System.in)); // 调用setSc方法

}

// System.out.println("书籍数据加载成功");

return;

}

}

}

// System.out.println("书籍数据加载失败");

}

}


BorrowRecord.java

package com.book;

import java.io.Serializable;

import java.util.Date;

import java.util.Scanner;



public class BorrowRecord implements Serializable {

/**

*

*/

private static final long serialVersionUID = 1L;

private String borrowRecordId; // 借阅记录ID

private String readerId; // 读者ID

private String bookId; // 书籍ID

private Date borrowDate; // 借阅日期

private Date returnDate; // 归还日期

private transient Scanner sc = new Scanner(System.in); // 扫描器对象



public void inputBorrowRecord() { // 输入借阅记录信息,并给属性赋值

System.out.println("请输入读者ID:");

readerId = sc.next();

System.out.println("请输入书籍ID:");

bookId = sc.next();

System.out.println("请输入借阅日期(yyyy-MM-dd):");

String borrowDateStr = sc.next();

borrowDate = DataIO.stringToDate(borrowDateStr); // 调用DataIO类的静态方法将字符串转换为日期对象

System.out.println("请输入归还日期(yyyy-MM-dd):");

String returnDateStr = sc.next();

returnDate = DataIO.stringToDate(returnDateStr); // 调用DataIO类的静态方法将字符串转换为日期对象

borrowRecordId = BorrowRecordManager.getBorrowRecordIdAutoIncrease(); // 调用BorrowRecordManager类的静态方法生成自动编号的ID

}



void outputBorrowRecord() { // 输出借阅记录信息

System.out.println("借阅记录ID: " + borrowRecordId);

System.out.println("读者ID: " + readerId);

System.out.println("书籍ID: " + bookId);

System.out.println("借阅日期: " + DataIO.dateToString(borrowDate)); // 调用DataIO类的静态方法将日期对象转换为字符串

System.out.println("归还日期: " + DataIO.dateToString(returnDate)); // 调用DataIO类的静态方法将日期对象转换为字符串

}



public String getBorrowRecordId() {

return borrowRecordId;

}



public void setBorrowRecordId(String borrowRecordId) {

this.borrowRecordId = borrowRecordId;

}





public String getReaderId () {

return readerId;

}



public void setReaderId (String readerId) {

this.readerId = readerId;

}



public String getBookId () {

return bookId;

}



public void setBookId (String bookId) {

this.bookId = bookId;

}



public Date getBorrowDate () {

return borrowDate;

}



public void setBorrowDate (Date borrowDate) {

this.borrowDate = borrowDate;

}



public Date getReturnDate () {

return returnDate;

}



public void setReturnDate (Date returnDate) {

this.returnDate = returnDate;

}

}


BorrowRecordManager.java

package com.book;



import java.util.ArrayList;

import java.util.List;



public class BorrowRecordManager {

private List<BorrowRecord> borrowRecordList = null; // 存储所有借阅记录对象的列表

private static int borrowRecordIDAuto = 1; // 借阅记录ID自动编号



public static String getBorrowRecordIdAutoIncrease() { // 生成自动编号的借阅记录ID

return "BR" + String.format("%06d", borrowRecordIDAuto++);

}



public BorrowRecordManager() { // 构造方法,初始化借阅记录列表为空的ArrayList

borrowRecordList = new ArrayList<>();

}



public void addBorrowRecord(BorrowRecord borrowRecord) { // 添加一个借阅记录对象到列表中

if (borrowRecord != null) {

borrowRecordList.add(borrowRecord);

System.out.println("添加成功");

} else {

System.out.println("添加失败");

}

}



public void removeBorrowRecord(String borrowRecordId) { // 根据借阅记录ID删除一个借阅记录对象

BorrowRecord borrowRecord = getBorrowRecord(borrowRecordId); // 查找要删除的借阅记录对象

if (borrowRecord != null) {

borrowRecordList.remove(borrowRecord); // 从列表中删除

System.out.println("删除成功");

} else {

System.out.println("删除失败");

}

}



public void updateBorrowRecord(String borrowRecordId) { // 根据借阅记录ID修改一个借阅记录对象的信息

BorrowRecord borrowRecord = getBorrowRecord(borrowRecordId); // 查找要修改的借阅记录对象

if (borrowRecord != null) {

borrowRecord.inputBorrowRecord(); // 输入新的信息并赋值给属性

System.out.println("修改成功");

} else {

System.out.println("修改失败");

}

}



public BorrowRecord getBorrowRecord(String borrowRecordId) { // 根据借阅记录ID查找并返回一个借阅记录对象

for (BorrowRecord br : borrowRecordList) { // 遍历列表中的每个借阅记录对象

if (br.getBorrowRecordId().equals(borrowRecordId)) { // 如果ID匹配,则返回该对象

return br;

}

}

return null; // 如果没有找到,则返回null

}



public List<BorrowRecord> getAllBorrowRecords() { // 返回所有借阅记录对象的列表

return borrowRecordList;

}



public void outputAllBorrowRecords() { // 输出所有借阅记录对象的信息

for (BorrowRecord br : borrowRecordList) {

System.out.println("---------------------------------");

br.outputBorrowRecord();

}

}

public void saveToFile() { // 将所有借阅记录对象保存到文件中

DataIO.saveObjectToFile(borrowRecordList, "borrowRecords.dat"); // 调用DataIO类的静态方法将列表保存到文件中

}



public List<BorrowRecord> getBorrowRecordsByReaderId(String readerId) { // 根据读者ID查询并返回一个列表

List<BorrowRecord> records = new ArrayList<>(); // 创建一个空的列表

for (BorrowRecord br : borrowRecordList) { // 遍历所有借阅记录对象

if (br.getReaderId().equals(readerId)) { // 如果读者ID匹配,则添加到列表中

records.add(br);

}

}

return records; // 返回列表

}

public void loadFromFile() { // 从文件中加载所有借阅记录对象到列表中

Object obj = DataIO.readObjectFromFile("borrowRecords.dat"); // 调用DataIO类的静态方法从文件中加载对象

if (obj instanceof List<?>) { // 判断是否是列表类型

List<?> list = (List<?>) obj;

if (!list.isEmpty()) {

Object firstObj = list.get(0);

if (firstObj instanceof BorrowRecord) {

this.borrowRecordList = (List<BorrowRecord>) list;

// System.out.println("借阅数据加载成功");

return;

}

}

}

// System.out.println("借阅数据加载失败");

}



}

DataIO.java

package com.book;

import java.io.*;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;



public class DataIO {

public static void saveObjectToFile(Object obj, String fileName) { // 将一个对象保存到文件中

try {

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(fileName)); // 创建一个对象输出流

oos.writeObject(obj); // 写入对象

oos.close(); // 关闭流

} catch (IOException e) {

e.printStackTrace();

}

}



public static Object readObjectFromFile(String fileName) { // 从文件中读取一个对象

try {

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fileName)); // 创建一个对象输入流

Object obj = ois.readObject(); // 读取对象

ois.close(); // 关闭流

return obj; // 返回对象

} catch (IOException | ClassNotFoundException e) {

// e.printStackTrace();

}

return null; // 如果发生异常,则返回null

}



public static String dateToString(Date date) { // 将一个日期对象转换为字符串

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 创建一个日期格式化对象

return sdf.format(date); // 返回格式化后的字符串

}



public static Date stringToDate(String str) { // 将一个字符串转换为日期对象

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 创建一个日期格式化对象

try {

return sdf.parse(str); // 返回解析后的日期对象

} catch (ParseException e) {

e.printStackTrace();

}

return null; // 如果发生异常,则返回null

}

}


LibrarySystem.java

package com.book;

import java.util.Map;

import java.util.Scanner;

import java.util.List;



public class LibrarySystem {

public static Scanner sc = new Scanner(System.in); // 扫描器对象

private ReaderManager readerManager = new ReaderManager(); // 读者管理对象

private BookManager bookManager = new BookManager(); // 书籍管理对象

private BorrowRecordManager borrowRecordManager = new BorrowRecordManager(); // 借阅记录管理对象

private LibWorkerManager libWorkerManager = new LibWorkerManager(); // 图书管理员管理对象



public void showMainMenu() {

System.out.println("*************一级菜单*************");

System.out.println("欢迎来到图书管理系统,请选择:");

System.out.println("1.读者界面");

System.out.println("2.图书管理员界面");

System.out.println("3.退出系统");

System.out.print("请选择操作1-3:");

int choice = sc.nextInt();

switch (choice) {

case 1:

showReaderLoginMenu(); // 显示二级菜单(读者登录界面)

break;

case 2:

showLibWorkerLoginMenu(); // 显示二级菜单(图书管理员登录界面)

break;

case 3:

System.exit(0); // 退出系统

break;

default:

System.out.println("输入错误,请重新输入");

showMainMenu(); // 重新显示一级菜单

break;

}

}



public void showReaderLoginMenu() {

System.out.println("*************二级菜单*************");

System.out.println("欢迎来到读者登录界面,请选择:");

System.out.println("1.登录");

System.out.println("2.注册");

System.out.println("3.返回上级菜单");

System.out.println("4.退出系统");

System.out.print("请选择操作1-4:");

int choice = sc.nextInt();

switch (choice) {

case 1:

loginReader(); // 登录读者账户

break;

case 2:

registerReader(); // 注册读者账户

break;

case 3:

showMainMenu(); // 返回上级菜单(一级菜单)

break;

case 4:

System.exit(0); // 退出系统

break;

default:

System.out.println("输入错误,请重新输入");

showReaderLoginMenu(); // 重新显示二级菜单(读者登录界面)

break;

}

}



public void loginReader() {

System.out.println("请输入登录名:");

String logName = sc.next();

System.out.println("请输入密码:");

String logCode = sc.next();

for (Reader r : readerManager.getAllReaders()) { // 遍历所有读者对象

if (r.getReaderLogName().equals(logName) && r.getReaderLogCode().equals(logCode)) { // 如果登录名和密码匹配,则登录成功

System.out.println("登录成功");

showReaderChoiceMenu(r); // 显示三级菜单(读者选择界面)

return;

}

}

System.out.println("登录失败"); // 如果没有匹配的读者对象,则登录失败

showReaderLoginMenu(); // 返回二级菜单(读者登录界面)

}



public void registerReader() {

Reader reader = new Reader(); // 创建一个新的读者对象

reader.inputReader(); // 输入并设置属性值

readerManager.addReader(reader); // 添加到读者列表中

readerManager.saveToFile(); // 保存到文件中

showReaderLoginMenu(); // 返回二级菜单(读者登录界面)

}



public void showReaderChoiceMenu(Reader reader) {

System.out.println("*************三级菜单*************");

System.out.println("欢迎来到读者选择界面,请选择:");

System.out.println("1.借阅信息查询");

System.out.println("2.书籍信息查询");

System.out.println("3.修改帐户信息");

System.out.println("4.返回上级菜单");

System.out.println("5.退出系统");

System.out.print("请选择操作1-5:");

int choice = sc.nextInt();

switch (choice) {

case 1:

queryBorrowInfo(reader); // 查询借阅信息

break;

case 2:

queryBookInfo(reader); // 查询书籍信息

break;

case 3:

modifyAccountInfo(reader); // 修改帐户信息

break;

case 4:

showReaderLoginMenu(); // 返回上级菜单(二级菜单)

break;

case 5:

System.exit(0); // 退出系统

break;

default:

System.out.println("输入错误,请重新输入");

showReaderChoiceMenu(reader); // 重新显示三级菜单(读者选择界面)

break;

}

}



public void queryBorrowInfo(Reader reader) {



System.out.println("你已经借阅了以下图书:");

reader.outputReader();

showReaderChoiceMenu(reader);

}



public void queryBookInfo(Reader reader) {



System.out.println("请输入你想要查询的图书名称:");

String bookName = sc.next();

List<Book> books = bookManager.getBooksByName(bookName);

if (books.isEmpty()) {

System.out.println("没有找到相关的图书");

} else {

System.out.println("找到了以下图书:");

for (Book b : books) {

b.outputBook();

}

}

showReaderChoiceMenu(reader);

}



public void modifyAccountInfo(Reader reader) {



System.out.println("请输入你想要修改的属性名称:");

System.out.println("1.姓名");

System.out.println("2.性别");

System.out.println("3.电话号码");

System.out.print("请选择操作1-3:");

int choice = sc.nextInt();

switch (choice) {

case 1: // 修改姓名

System.out.println("请输入新的姓名:");

String newName = sc.next();

reader.setName(newName); // 设置新的姓名

break;

case 2: // 修改性别

System.out.println("请输入新的性别:");

String newGender = sc.next();

reader.setGender(newGender); // 设置新的性别

break;

case 3: // 修改电话号码

System.out.println("请输入新的电话号码:");

String newPhone = sc.next();

reader.setPhone(newPhone); // 设置新的电话号码

break;

default:

System.out.println("输入错误,请重新输入");

modifyAccountInfo(reader); // 重新修改账户信息

break;

}

readerManager.saveToFile(); // 保存到文件中

showReaderChoiceMenu(reader); // 返回三级菜单(读者选择界面)

}



public void showLibWorkerLoginMenu() { // 显示二级菜单(图书管理员登录界面)

System.out.println("*************二级菜单*************");

System.out.println("欢迎来到图书管理员登录界面,请选择:");

System.out.println("1.登录");

System.out.println("2.注册");

System.out.println("3.返回上级菜单");

System.out.println("4.退出系统");

System.out.print("请选择操作1-4:");

int choice = sc.nextInt();

switch (choice) {

case 1:

loginLibWorker(); // 登录图书管理员账户

break;

case 2:

registerLibWorker(); // 注册图书管理员账户

break;

case 3:

showMainMenu(); // 返回上级菜单(一级菜单)

break;

case 4:

System.exit(0); // 退出系统

break;

default:

System.out.println("输入错误,请重新输入");

showLibWorkerLoginMenu(); // 重新显示二级菜单(图书管理员登录界面)

break;

}

}



public void loginLibWorker() { // 登录图书管理员账户

System.out.println("请输入登录名:");

String logName = sc.next();

System.out.println("请输入密码:");

String logCode = sc.next();

for (LibWorker lw : libWorkerManager.getAllLibWorkers()) { // 遍历所有图书管理员对象

if (lw.getLibWorkerLogName().equals(logName) && lw.getLibWorkerLogCode().equals(logCode)) { // 如果登录名和密码匹配,则登录成功

System.out.println("登录成功");

showLibWorkerChoiceMenu(lw); // 显示三级菜单(图书管理员选择界面)

return;

}

}

System.out.println("登录失败"); // 如果没有匹配的图书管理员对象,则登录失败

showLibWorkerLoginMenu(); // 返回二级菜单(图书管理员登录界面)

}



public void registerLibWorker() { // 注册图书管理员账户

LibWorker libWorker = new LibWorker(); // 创建一个新的图书管理员对象

libWorker.inputLibWorker(); // 输入并设置属性值

libWorkerManager.addLibWorker(libWorker); // 添加到图书管理员列表中

libWorkerManager.saveToFile(); // 保存到文件中

showLibWorkerLoginMenu(); // 返回二级菜单(图书管理员登录界面)

}



public void showLibWorkerChoiceMenu(LibWorker libWorker) { // 显示三级菜单(图书管理员选择界面)

System.out.println("*************三级菜单*************");

System.out.println("欢迎来到图书管理员选择界面,请选择:");

System.out.println("1.借阅管理");

System.out.println("2.读者管理");

System.out.println("3.书籍管理");

System.out.println("4.图书管理员账户信息设置");

System.out.println("5.返回上级菜单");

System.out.println("6.退出系统");

System.out.print("请选择操作1-6:");

int choice = sc.nextInt();

switch (choice) {

case 1:

showBorrowManageMenu(libWorker); // 显示四级菜单(借阅管理界面)

break;

case 2:

showReaderManageMenu(libWorker); // 显示四级菜单(读者管理界面)

break;

case 3:

showBookManageMenu(libWorker); // 显示四级菜单(书籍管理界面)

break;

case 4:

modifyAccountInfo(libWorker); // 修改账户信息

break;

case 5:

showLibWorkerLoginMenu(); // 返回上级菜单(二级菜单)

break;

case 6:

System.exit(0); // 退出系统

break;

default:

System.out.println("输入错误,请重新输入");

showLibWorkerChoiceMenu(libWorker); // 重新显示三级菜单(图书管理员选择界面)

break;

}

}



public void showBorrowManageMenu(LibWorker libWorker) {

// 显示四级菜单(借阅管理界面)

System.out.println("*************四级菜单*************");

System.out.println("欢迎来到借阅管理界面,请选择:");

System.out.println("1.查看所有用户借阅记录");

System.out.println("2.查看某个用户的所有借阅记录");

System.out.println("3.读者借阅/归还");

System.out.println("4.返回上级菜单");

System.out.print("请选择操作1-4:");

int choice = sc.nextInt();

switch (choice) {

case 1:

outputAllBorrowRecords();

showBorrowManageMenu(libWorker);

break;

case 2:

outputBorrowRecordsByReaderId();

showBorrowManageMenu(libWorker);

break;

case 3:

borrowOrReturnBook();

showBorrowManageMenu(libWorker);

break;

case 4:

showLibWorkerChoiceMenu(libWorker);

showBorrowManageMenu(libWorker);

break;

default:

System.out.println("输入错误,请重新输入");

showBorrowManageMenu(libWorker);

break;

}

}



public void outputAllBorrowRecords() {

// 输出所有用户借阅记录

borrowRecordManager.outputAllBorrowRecords();

}



public void outputBorrowRecordsByReaderId() {

// 输出某个用户的所有借阅记录

System.out.println("请输入要查询的用户ID:");

String readerId = sc.next();

List<BorrowRecord> records = borrowRecordManager.getBorrowRecordsByReaderId(readerId);

if (records.isEmpty()) {

System.out.println("该用户没有借阅记录");

} else {

for (BorrowRecord br : records) {

br.outputBorrowRecord();

}

}



}



public void borrowOrReturnBook() {



// 实现读者借阅/归还功能



// 首先,根据读者ID查找对应的读者对象,如果不存在,则提示错误并返回



System.out.println("请输入读者ID:");



String readerId = sc.next();



Reader reader = readerManager.getReader(readerId);



if (reader == null) {



System.out.println("该读者不存在");



return;



}



// 其次,根据书籍ID查找对应的书籍对象,如果不存在,则提示错误并返回



System.out.println("请输入书籍ID:");



String bookId = sc.next();



Book book = bookManager.getBook(bookId);



if (book == null) {



System.out.println("该书籍不存在");



return;



}



// 然后,判断该读者是否已经借阅了该书籍,如果是,则执行归还操作,否则执行借阅操作



Map<String, BorrowRecord> borrowedBookInfo = reader.getBorrowedBookInfo();



if (borrowedBookInfo.containsKey(bookId)) {



// 执行归还操作



// 首先,从读者的借阅信息中移除该条记录,并从借阅记录列表中删除该条记录



BorrowRecord borrowRecord = borrowedBookInfo.remove(bookId);



borrowRecordManager.removeBorrowRecord(borrowRecord.getBorrowRecordId());



// 其次,将该书籍的状态设置为可借,并更新到文件中



book.setBookState(true);



bookManager.saveToFile();



// 最后,输出归还成功的提示信息



System.out.println("归还成功");





} else {



// 执行借阅操作



// 首先,判断该书籍是否可借,如果不可借,则提示错误并返回



if (!book.isBookState()) {



System.out.println("该书籍不可借");



return;



}

// 其次,创建一个新的借阅记录对象,并输入并设置属性值

BorrowRecord borrowRecord = new BorrowRecord();

borrowRecord.inputBorrowRecord();



// 然后,将该借阅记录对象添加到读者的借阅信息中,并添加到借阅记录列表中

borrowedBookInfo.put(bookId, borrowRecord);

borrowRecordManager.addBorrowRecord(borrowRecord);



// 接着,将该书籍的状态设置为不可借,并更新到文件中

book.setBookState(false);

bookManager.saveToFile();



// 最后,输出借阅成功的提示信息

System.out.println("借阅成功");

}

borrowRecordManager.saveToFile(); // 保存借阅记录到文件中

readerManager.saveToFile(); // 保存读者信息到文件中

}



public void showReaderManageMenu(LibWorker libWorker) { // 显示四级菜单(读者管理界面)

System.out.println("*************四级菜单*************");

System.out.println("欢迎来到读者管理界面,请选择:");

System.out.println("1.添加读者");

System.out.println("2.删除读者");

System.out.println("3.修改读者");

System.out.println("4.查询读者");

System.out.println("5.显示所有读者");

System.out.println("6.返回上级菜单");

System.out.print("请选择操作1-6:");

int choice = sc.nextInt();

switch (choice) {

case 1:

addReader(); // 添加读者

showReaderManageMenu(libWorker);

break;

case 2:

removeReader(); // 删除读者

showReaderManageMenu(libWorker);

break;

case 3:

updateReader(); // 修改读者

showReaderManageMenu(libWorker);

break;

case 4:

getReader(); // 查询读者

showReaderManageMenu(libWorker);

break;

case 5:

outputAllReaders(); // 显示所有读者

showReaderManageMenu(libWorker);

break;

case 6:

showLibWorkerChoiceMenu(libWorker); // 返回上级菜单(三级菜单)

break;

default:

System.out.println("输入错误,请重新输入");

showReaderManageMenu(libWorker); // 重新显示四级菜单(读者管理界面)

break;

}

}



public void addReader() { // 添加读者

Reader reader = new Reader(); // 创建一个新的读者对象

reader.inputReader(); // 输入并设置属性值

readerManager.addReader(reader); // 添加到读者列表中

readerManager.saveToFile(); // 保存到文件中

}



public void removeReader() { // 删除读者

System.out.println("请输入要删除的读者ID:");

String readerId = sc.next();

readerManager.removeReader(readerId); // 根据ID删除对应的读者对象

readerManager.saveToFile(); // 保存到文件中

}



public void updateReader() { // 修改读者

System.out.println("请输入要修改的读者ID:");

String readerId = sc.next();

readerManager.updateReader(readerId); // 根据ID修改对应的读者对象

readerManager.saveToFile(); // 保存到文件中

}



public void getReader() { // 查询读者

System.out.println("请输入要查询的读者ID:");

String readerId = sc.next();

Reader reader = readerManager.getReader(readerId); // 根据ID查找对应的读者对象

if (reader != null) {

reader.outputReader(); // 如果存在,则输出信息

} else {

System.out.println("该读者不存在"); // 如果不存在,则提示错误

}

}



public void outputAllReaders() { // 显示所有读者

readerManager.outputAllReaders(); // 输出所有读者对象的信息

}



public void showBookManageMenu(LibWorker libWorker) {

// 显示四级菜单(书籍管理界面)

System.out.println("*************四级菜单*************");

System.out.println("欢迎来到书籍管理界面,请选择:");

System.out.println("1.添加书籍");

System.out.println("2.删除书籍");

System.out.println("3.修改书籍");

System.out.println("4.查询书籍");

System.out.println("5.显示所有书籍");

System.out.println("6.返回上级菜单");

System.out.print("请选择操作1-6:");

int choice = sc.nextInt();

switch (choice) {

case 1:

addBook();

showBookManageMenu(libWorker);

break;

case 2:

removeBook();

showBookManageMenu(libWorker);

break;

case 3:

updateBook();

showBookManageMenu(libWorker);

break;

case 4:

getBook();

showBookManageMenu(libWorker);

break;

case 5:

outputAllBooks();

showBookManageMenu(libWorker);

break;

case 6:

showLibWorkerChoiceMenu(libWorker);

break;

default:

System.out.println("输入错误,请重新输入");

showBookManageMenu(libWorker);

break;

}



}



public void addBook() {



// 添加书籍



Book book = new Book();



book.inputBook();



bookManager.addBook(book);



bookManager.saveToFile();



}



public void removeBook() {



// 删除书籍



System.out.println("请输入要删除的书籍ID:");



String bookId = sc.next();



bookManager.removeBook(bookId);



bookManager.saveToFile();



}



public void updateBook() {



// 修改书籍



System.out.println("请输入要修改的书籍ID:");



String bookId = sc.next();



bookManager.updateBook(bookId);



bookManager.saveToFile();



}



public void getBook() {



// 查询书籍



System.out.println("请输入要查询的方式:");



System.out.println("1.按照书籍ID查询");



System.out.println("2.按照书籍名称模糊查询");



System.out.println("3.按照ISBN号查询");



int choice = sc.nextInt();



switch (choice) {



case 1: // 按照书籍ID查询



System.out.println("请输入要查询的书籍ID:");



String bookId = sc.next();



Book book = bookManager.getBook(bookId);



if (book != null) {



book.outputBook();



} else {



System.out.println("该书籍不存在");



}



break;



case 2: // 按照书籍名称模糊查询



System.out.println("请输入要查询的书籍名称关键字:");



String name = sc.next();



List<Book> booksByName = bookManager.getBooksByName(name);



if (booksByName.isEmpty()) {



System.out.println("没有找到匹配的书籍");



} else {



for (Book b : booksByName) {



b.outputBook();



}



}



break;



case 3: // 按照ISBN号查询



System.out.println("请输入要查询的ISBN号:");



String isbn = sc.next();



List<Book> booksByISBN = bookManager.getBooksByISBN(isbn);



if (booksByISBN.isEmpty()) {



System.out.println("没有找到匹配的书籍");



} else {



for (Book b : booksByISBN) {



b.outputBook();



}



}



break;



default:



System.out.println("输入错误,请重新输入");



getBook();



break;



}



}



public void outputAllBooks() {



// 显示所有书籍



bookManager.outputAllBooks();



}



public void modifyAccountInfo(LibWorker libWorker) {



// 修改账户信息



System.out.println("请输入你想要修改的属性名称:");



System.out.println("1.姓名");



System.out.println("2.性别");



System.out.println("3.电话号码");



System.out.print("请选择操作1-3:");



int choice = sc.nextInt();



switch (choice) {



case 1: // 修改姓名



System.out.println("请输入新的姓名:");



String newName = sc.next();



libWorker.setName(newName); // 设置新的姓名



break;



case 2: // 修改性别



System.out.println("请输入新的性别:");



String newGender = sc.next();



libWorker.setGender(newGender); // 设置新的性别



break;



case 3: // 修改电话号码



System.out.println("请输入新的电话号码:");



String newPhone = sc.next();



libWorker.setPhone(newPhone); // 设置新的电话号码



break;



default:



System.out.println("输入错误,请重新输入");



modifyAccountInfo(libWorker); // 重新修改账户信息



break;



}



libWorkerManager.saveToFile(); // 保存到文件中



showLibWorkerChoiceMenu(libWorker); // 返回三级菜单(图书管理员选择界面)



}

public void init() { // 初始化数据

bookManager.loadFromFile(); // 从文件中加载书籍列表

readerManager.loadFromFile(); // 从文件中加载读者列表

libWorkerManager.loadFromFile(); // 从文件中加载图书管理员列表

borrowRecordManager.loadFromFile(); // 从文件中加载借阅记录列表

}



public static void main(String[] args) {

LibrarySystem ls = new LibrarySystem(); // 创建一个图书馆系统对象

ls.init(); // 初始化数据

ls.showMainMenu(); // 显示一级菜单(主界面)

}



}


LibWorker.java

package com.book;

import java.io.Serializable;

import java.util.Scanner;



public class LibWorker implements Serializable {

/**

*

*/

private static final long serialVersionUID = 1L;

private String libWorkerLogName; // 图书管理员登录名

private String libWorkerLogCode; // 图书管理员登录密码

private String libWorkerId; // 图书管理员ID

private String name; // 图书管理员姓名

private String gender; // 图书管理员性别

private String phone; // 图书管理员电话号码

private int age = 0; // 图书管理员年龄

private transient Scanner sc = new Scanner(System.in); // 扫描器对象



public void inputLibWorker() {

// 检查图书管理员是否为空或已经存在

System.out.println("请输入图书管理员登录名:");

// 使用while循环和if语句来检查用户输入的登录名是否为空或已经存在于图书管理员管理器中

while (true) {

// 读取用户输入的图书管理员登录名

libWorkerLogName = sc.next();

// 如果为空,就提示用户不能为空

if (libWorkerLogName.isEmpty()) {

System.out.println("输入错误,图书管理员登录名不能为空。");

}

// 如果已经存在,就提示用户已经注册过了

else if (LibWorkerManager.isLibWorkerLogNameExist(libWorkerLogName)) {

System.out.println("输入错误,该图书管理员登录名已经被注册过了。");

}

// 如果既不为空也不存在,就跳出循环

else {

break;

}

System.out.println("请重新输入图书管理员登录名:");

}



// 检查图书管理员登录密码是否为空或太简单

System.out.println("请输入图书管理员登录密码:");

libWorkerLogCode = sc.next();

// 使用正则表达式来匹配至少包含一个数字,一个大写字母,一个小写字母并且长度为8到16位的密码

String codeRegex = "^(?=.*\\d)(?=.*[a-z])(?=.*[A-Z]).{8,16}$";

// 使用while循环和if语句来检查用户输入的密码是否为空或不匹配正则表达式

while (libWorkerLogCode.isEmpty() || !libWorkerLogCode.matches(codeRegex)) {

// 如果为空或不匹配,就提示用户重新输入

System.out.println("输入错误,密码至少包含一个数字,一个大写字母,一个小写字母并且长度为8到16位");

System.out.println("请重新输入:");

libWorkerLogCode = sc.next();

}



// 检查图书管理员姓名是否为空或包含非法字符

System.out.println("请输入图书管理员姓名:");

name = sc.next();

// 使用正则表达式来匹配只包含中文或英文字符的姓名

String nameRegex = "^[\\u4e00-\\u9fa5a-zA-Z]+$";

// 使用while循环和if语句来检查用户输入的姓名是否为空或不匹配正则表达式

while (name.isEmpty() || !name.matches(nameRegex)) {

// 如果为空或不匹配,就提示用户重新输入

System.out.println("输入错误,请输入合法的姓名:");

name = sc.next();

}



// 检查图书管理员性别是否为男或女

System.out.println("请输入图书管理员性别:");

gender = sc.next();

// 使用while循环和if语句来检查用户输入的性别是否为男或女

while (!gender.equals("男") && !gender.equals("女")) {

// 如果不是,就提示用户重新输入

System.out.println("输入错误,请输入男或女:");

gender = sc.next();

}

// 检查图书管理员电话号码是否为11位数字

System.out.println("请输入图书管理员电话号码:");

phone = sc.next();

// 使用正则表达式来匹配11位数字

String phoneRegex = "^\\d{11}$";

// 使用while循环和if语句来检查用户输入的电话号码是否匹配正则表达式

while (!phone.matches(phoneRegex)) {

// 如果不匹配,就提示用户重新输入

System.out.println("输入错误,请输入11位数字:");

phone = sc.next();

}



// 检查图书管理员年龄是否为正整数

System.out.println("请输入图书管理员年龄:");

age = sc.nextInt();

// 使用while循环和if语句来检查用户输入的年龄是否为正整数

while (age <=0) {

// 如果不是,就提示用户重新输入

System.out.println("输入错误,请输入正整数:");

age = sc.nextInt();

}



}





void outputLibWorker() {

System.out.println("登录名: " + libWorkerLogName);

System.out.println("登录密码: " + libWorkerLogCode);

System.out.println("ID: " + libWorkerId);

System.out.println("姓名: " + name);

System.out.println("性别: " + gender);

System.out.println("电话号码: " + phone);

System.out.println("年龄: " + age);

}



public String getLibWorkerLogName() {

return libWorkerLogName;

}



public void setLibWorkerLogName(String libWorkerLogName) {

this.libWorkerLogName = libWorkerLogName;

}



public String getLibWorkerLogCode() {

return libWorkerLogCode;

}



public void setLibWorkerLogCode(String libWorkerLogCode) {

this.libWorkerLogCode = libWorkerLogCode;

}



public String getLibWorkerId() {

return libWorkerId;

}



public void setLibWorkerId(String libWorkerId) {

this.libWorkerId = libWorkerId;

}



public String getName() {

return name;

}



public void setName(String name) {

this.name = name;

}





public String getGender () {

return gender;

}



public void setGender (String gender) {

this.gender = gender;

}



public String getPhone () {

return phone;

}



public void setPhone (String phone) {

this.phone = phone;

}



public int getAge () {

return age;

}



public void setAge (int age) {

this.age = age;

}

}


LibWorkerManager.java

package com.book;



import java.util.ArrayList;

import java.util.List;



public class LibWorkerManager {

private static List<LibWorker> libWorkerList = null;

private static int libWorkerIDAuto = 1; // 图书管理员ID自动编号



public static String getLibWorkerIdAutoIncrease() {

return "LW" + String.format("%06d", libWorkerIDAuto++);

}



public LibWorkerManager() {

libWorkerList = new ArrayList<>(); // 初始化为空的列表

}





public static boolean isLibWorkerLogNameExist(String readerLogName) {

// 遍历读者列表,查找是否有匹配的读者登录名

for (LibWorker l : libWorkerList) {

// 如果有,就返回true

if (l.getLibWorkerLogName().equals(readerLogName)) {

return true;

}

}

// 如果没有,就返回false

return false;

}





// 在添加libWorker的时候,新增的libWorker设置libWorkerId,应直接调用getRecordIdAutoIncrease获取。

public void addLibWorker(LibWorker libWorker) {

if (libWorker != null) {

libWorkerList.add(libWorker); // 添加到列表中

System.out.println("添加成功");

} else {

System.out.println("添加失败");

}

}



public void removeLibWorker(String libWorkerId) {

LibWorker libWorker = getLibWorker(libWorkerId); // 查找要删除的图书管理员对象

if (libWorker != null) {

libWorkerList.remove(libWorker); // 从列表中删除

System.out.println("删除成功");

} else {

System.out.println("删除失败");

}

}



// 只对已存在的图书管理员进行信息的更新。

public void updateLibWorker(String libWorkerId) {

LibWorker libWorker = getLibWorker(libWorkerId); // 查找要修改的图书管理员对象

if (libWorker != null) {

libWorker.inputLibWorker(); // 输入新的信息并赋值给属性

System.out.println("修改成功");

} else {

System.out.println("修改失败");

}

}



public LibWorker getLibWorker(String libWorkerId) {

for (LibWorker lw : libWorkerList) { // 遍历列表中的每个图书管理员对象

if (lw.getLibWorkerId().equals(libWorkerId)) { // 如果ID匹配,则返回该对象

return lw;

}

}

return null; // 如果没有找到,则返回null

}



public List<LibWorker> getAllLibWorkers() {

return libWorkerList; // 返回所有图书管理员对象的列表

}



public void outputAllLibWorkers() {

for (LibWorker lw : libWorkerList) { // 遍历列表中的每个图书管理员对象并输出信息

System.out.println("---------------------------");

lw.outputLibWorker();

}

}



public void saveToFile() {

DataIO.saveObjectToFile(libWorkerList, "libWorkers.dat"); // 调用DataIO类的静态方法将列表保存到文件中

}



public void loadFromFile() {

Object obj = DataIO.readObjectFromFile("libWorkers.dat"); // 调用DataIO类的静态方法从文件中加载对象

if (obj instanceof List<?>) { // 判断是否是列表类型

List<?> list = (List<?>) obj;

if (!list.isEmpty()) {

Object firstObj = list.get(0);

if (firstObj instanceof LibWorker) { // 判断是否是图书管理员类型

this.libWorkerList = (List<LibWorker>) list; // 将对象转换为图书管理员列表并赋值给属性

// System.out.println("管理员数据加载成功");

return;

}

}

}

// System.out.println("管理员数据加载失败");

}

}

Reader.java

package com.book;

import java.io.Serializable;

import java.util.HashMap;

import java.util.Map;

import java.util.Scanner;



public class Reader implements Serializable, Comparable<Reader>{

/**

*

*/

private static final long serialVersionUID = -8846367975888923848L;

private String readerLogName; // 读者登录名

private String readerLogCode; // 读者登录密码

private String readerId; // 读者ID

private String name; // 读者姓名

private String gender; // 读者性别

private String phone; // 读者电话号码

private int age = 0; // 读者年龄

private int leftMoney = 0; // 读者账户余额

private Map<String, BorrowRecord> borrowedBookInfo = null; // 读者借阅的图书信息

private transient Scanner sc = new Scanner(System.in); // 扫描器对象



public Map<String, BorrowRecord> getBorrowedBookInfo() {

return borrowedBookInfo;

}



public Reader() {



}



public void inputReader() {

// 检查读者登录名是否为空或已经存在

System.out.println("请输入读者登录名:");

// 使用while循环和if语句来检查用户输入的登录名是否为空或已经存在于读者管理器中

while (true) {

// 读取用户输入的读者登录名



readerLogName = sc.next();

// 如果为空,就提示用户不能为空

if (readerLogName.isEmpty()) {

System.out.println("输入错误,读者登录名不能为空。");

}

// 如果已经存在,就提示用户已经注册过了

else if (ReaderManager.isReaderExist(readerLogName)) {

System.out.println("输入错误,该读者登录名已经被注册过了。");

}

// 如果既不为空也不存在,就跳出循环

else {

break;

}

System.out.println("请重新输入读者登录名:");

}





// 检查读者登录密码是否为空或太简单

System.out.println("请输入读者登录密码:");

readerLogCode = sc.next();

// 使用正则表达式来匹配至少包含一个数字,一个大写字母,一个小写字母并且长度为8到16位的密码

String codeRegex = "^(?=.*\\d)(?=.*[a-z])(?=.*[A-Z]).{8,16}$";

// 使用while循环和if语句来检查用户输入的密码是否为空或不匹配正则表达式

while (readerLogCode.isEmpty() || !readerLogCode.matches(codeRegex)) {

// 如果为空或不匹配,就提示用户重新输入

System.out.println("输入错误,密码至少包含一个数字,一个大写字母,一个小写字母并且长度为8到16位");

System.out.println("请重新输入:");

readerLogCode = sc.next();

}



// 检查读者姓名是否为空或包含非法字符

System.out.println("请输入读者姓名:");

name = sc.next();

// 使用正则表达式来匹配只包含中文或英文字符的姓名

String nameRegex = "^[\\u4e00-\\u9fa5a-zA-Z]+$";

// 使用while循环和if语句来检查用户输入的姓名是否为空或不匹配正则表达式

while (name.isEmpty() || !name.matches(nameRegex)) {

// 如果为空或不匹配,就提示用户重新输入

System.out.println("输入错误,请输入合法的姓名:");

name = sc.next();

}



// 检查读者性别是否为男或女

System.out.println("请输入读者性别:");

gender = sc.next();

// 使用while循环和if语句来检查用户输入的性别是否为男或女

while (!gender.equals("男") && !gender.equals("女")) {

// 如果不是,就提示用户重新输入

System.out.println("输入错误,请输入男或女:");

gender = sc.next();

}



// 检查读者电话号码是否为11位数字

System.out.println("请输入读者电话号码:");

phone = sc.next();

// 使用正则表达式来匹配11位数字

String phoneRegex = "^\\d{11}$";

// 使用while循环和if语句来检查用户输入的电话号码是否匹配正则表达式

while (!phone.matches(phoneRegex)) {

// 如果不匹配,就提示用户重新输入

System.out.println("输入错误,请输入11位数字:");

phone = sc.next();

}



// 检查读者年龄是否为正整数

System.out.println("请输入读者年龄:");

age = sc.nextInt();

// 使用while循环和if语句来检查用户输入的年龄是否为正整数

while (age <=0) {

// 如果不是,就提示用户重新输入

System.out.println("输入错误,请输入正整数:");

age = sc.nextInt();

}



// 检查读者账户余额是否为非负整数

System.out.println("请输入读者账户余额:");

leftMoney = sc.nextInt();

// 使用while循环和if语句来检查用户输入的账户余额是否为非负整数

while (leftMoney < 0) {

// 如果不是,就提示用户重新输入

System.out.println("输入错误,请输入非负整数:");

leftMoney = sc.nextInt();

}



// 其他代码不变

readerId = ReaderManager.getReaderIdAutoIncrease();

borrowedBookInfo = new HashMap<>();

}





void outputReader() {

System.out.println("登录名: " + readerLogName);

System.out.println("登录密码: " + readerLogCode);

System.out.println("ID: " + readerId);

System.out.println("姓名: " + name);

System.out.println("性别: " + gender);

System.out.println("电话号码: " + phone);

System.out.println("年龄: " + age);

System.out.println("账户余额: " + leftMoney);

if (borrowedBookInfo.isEmpty()) {

System.out.println("没有借阅任何图书");

} else {

System.out.println("借阅的图书信息如下:");

for (BorrowRecord br : borrowedBookInfo.values()) {

br.outputBorrowRecord();

}

}

}



public String getReaderLogName() {

return readerLogName;

}



public void setReaderLogName(String readerLogName) {

this.readerLogName = readerLogName;

}



public String getReaderLogCode() {

return readerLogCode;

}



public void setReaderLogCode(String readerLogCode) {

this.readerLogCode = readerLogCode;

}



public String getReaderId() {

return readerId;

}



public void setReaderId(String readerId) {

this.readerId = readerId;

}



public String getName() {

return name;

}



public void setName(String name) {

this.name = name;

}



public String getGender() {

return gender;

}



public void setGender(String gender) {

this.gender = gender;

}



public int getAge() {

return age;

}



public void setAge(int age) {

this.age = age;

}



public String getPhone() {

return phone;

}



public void setPhone(String phone) {

this.phone = phone;

}

public int getLeftMoney() { // 获取账户余额

return leftMoney;

}



public void setLeftMoney(int leftMoney) { // 设置账户余额

this.leftMoney = leftMoney;

}





@Override

public int compareTo(Reader other) { // 按照ID升序排序

return this.readerId.compareTo(other.readerId);

}

// 添加一个public的setter方法,用来设置sc的值

public void setSc(Scanner sc) {

this.sc = sc;

}



}


ReaderManager.java

package com.book;



import java.util.*;

import java.util.ArrayList;

import java.util.List;

import java.util.Map; // 导入Map类



public class ReaderManager {

private static List<Reader> readerList = null;

private static int readerIDAuto = 1; // 读者ID自动编号



public static String getReaderIdAutoIncrease() {

return "RE" + String.format("%06d", readerIDAuto++);

}



public ReaderManager() {

readerList = new ArrayList<>(); // 初始化为空的列表

}



public static boolean isReaderExist(String readerLogName) {

// 遍历读者列表,查找是否有匹配的读者登录名

for (Reader r : readerList) {

// 如果有,就返回true

if (r.getReaderLogName().equals(readerLogName)) {

return true;

}

}

// 如果没有,就返回false

return false;

}



// 在添加reader的时候,新增的reader设置readerId,应直接调用getRecordIdAutoIncrease获取。

public void addReader(Reader reader) {

if (reader != null) {

readerList.add(reader); // 添加到列表中

System.out.println("添加成功");

} else {

System.out.println("添加失败");

}

}



public void removeReader(String readerId) {

Reader reader = getReader(readerId); // 查找要删除的读者对象

if (reader != null) {

readerList.remove(reader); // 从列表中删除

System.out.println("删除成功");

} else {

System.out.println("删除失败");

}

}



// 只对已存在的读者进行信息的更新。

public void updateReader(String readerId) {

Reader reader = getReader(readerId); // 查找要修改的读者对象

if (reader != null) {

reader.inputReader(); // 输入新的信息并赋值给属性

System.out.println("修改成功");

} else {

System.out.println("修改失败");

}

}





public void borrowBook(BorrowRecord br) {

if (br != null) {

Reader reader = getReader(br.getReaderId()); // 查找借阅图书的读者对象

if (reader != null) {

Map<String, BorrowRecord> borrowedBookInfo = reader.getBorrowedBookInfo(); // 获取借阅图书信息

borrowedBookInfo.put(br.getBookId(), br); // 添加新的借阅记录到哈希表中

int leftMoney = reader.getLeftMoney(); // 获取账户余额

leftMoney -= 5; // 借阅一本图书扣除5元费用

reader.setLeftMoney(leftMoney); // 更新账户余额

System.out.println("借阅成功");

} else {

System.out.println("借阅失败");

}

} else {

System.out.println("借阅失败");

}

}



public void returnBook(BorrowRecord br) {

if (br != null) {

Reader reader = getReader(br.getReaderId()); // 查找归还图书的读者对象

if (reader != null) {

Map<String, BorrowRecord> borrowedBookInfo = reader.getBorrowedBookInfo(); // 获取借阅图书信息

borrowedBookInfo.remove(br.getBookId()); // 删除对应的借阅记录从哈希表中

int leftMoney = reader.getLeftMoney(); // 获取账户余额

leftMoney += 5; // 归还一本图书返还5元费用

reader.setLeftMoney(leftMoney); // 更新账户余额

System.out.println("归还成功");

} else {

System.out.println("归还失败");

}

} else {

System.out.println("归还失败");

}

}



public Reader getReader(String readerId) {

for (Reader r : readerList) { // 遍历列表中的每个读者对象

if (r.getReaderId().equals(readerId)) { // 如果ID匹配,则返回该对象

return r;

}

}

return null; // 如果没有找到,则返回null

}



public List<Reader> getAllReaders() {

return readerList; // 返回所有读者对象的列表

}



public void outputAllReaders() {

for (Reader r : readerList) { // 遍历列表中的每个读者对象并输出信息

System.out.println("---------------------------");

r.outputReader();



}

}



public void saveToFile() {

DataIO.saveObjectToFile(readerList, "readers.dat"); // 调用DataIO类的静态方法将列表保存到文件中

}



public void loadFromFile() {

Object obj = DataIO.readObjectFromFile("readers.dat"); // 调用DataIO类的静态方法从文件中加载对象

if (obj instanceof List<?>) { // 判断是否是列表类型

List<?> list = (List<?>) obj;

if (!list.isEmpty()) {

Object firstObj = list.get(0);

if (firstObj instanceof Reader) {

this.readerList = (List<Reader>) list;

// System.out.println("读者数据加载成功");

for (Reader r : readerList) {

r.setSc(new Scanner(System.in)); // 调用setter方法

}

return;

}

}

}

// System.out.println("读者数据加载失败");

}

}