分析：
1.定义系统功能模块，用类来实现
Login（登录注册）
管理员：
JobEnter(兼职信息投放功能)，Management（系统管理功能）,Vindicate(基本信息维护功能),
普通用户：
JobFunction(兼职申请功能)，ModifyCpmmon(个人信息修改)
2.定义包装类
ActiveUser(学生登录以后把对应的对象、在用户列表中的索引，对应的信用等级带入)，User(用户的基本信息),UserAccount(用户信用系数以及余额，是User中的成员)，Job(兼职信息)，JobType(是兼职信息中的其中一个模块，包括兼职的JTID),ApplyJob(学生申请兼职以后会生成一个对象用于保存学生的UID，兼职信息的JTID,以及开始时间和结束时间)
3.建立txt文件，用于保存数据
ApplyJobList(保存用户申请兼职以后得到的ApplyJob对象，使用集合保存ApplyJob，存入的是集合)，EnteringList(这里存入的是管理员录入的学生信息，是用键值对存放，存放的是Map集合,键为学生的UID，值为学生的姓名，只有找到对应的键值对，学生才能注册)，UserList(存放的是学生注册成功以后得到的User对象形成的集合)，JobMessage（存放的是管理员录入的兼职信息Job形成的集合）
4.建立视图模块，用于展示每一个模块
5.这里的UID使用正则表达式/w{10}，让输入的UID必须是10个字符，其中前7个字符组成如果是"student"，那么就是普通用户；如果是"teacher"，那么就是管理员
6.用户兼职申请必须满足对应的兼职的信用等级，普通用户的信用等级分别为：无，极差，较差，良好，优秀，极优。兼职的信用等级分别为：一，二，三，四，五。如果用户的信用等级为“无”，那么就不能申请兼职，如果用户的信用等级为“极差”，那么用户只能申请等级为“一”的兼职，如果用户为“较差”，那么用户可以申请“一”和“二”的兼职任务，依次类推。
7.系统管理模块的删除功能：
如果管理员删除录入的信息，那么学生的申请信息以及注册信息也要一起被删除；
如果管理员删除用户的注册信息，那么如果用户没有正在执行的兼职，就可以删除，如果有就不可以删除；
如果管理员删除兼职信息，如果兼职被用户申请并且还正在执行，则不能删除该兼职信息。
8.因为方便测试，我这里使用的时间都是毫秒计算
功能实现：
包装类：
ActiveUser:
public class ActiveUser implements Serializable {
//成员变量
private User user;//用户信息
private int index;//在用户列表中的索引
private String credit;//对应的信用
//构造器
public ActiveUser(User user, int index) {
this.user = user;
this.index = index;
}
public ActiveUser(User user, int index, String credit) {
this.user = user;
this.index = index;
this.credit = credit;
}
//使用get//set方法
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public String getCredit() {
return credit;
}
public void setCredit(String credit) {
this.credit = credit;
}
//toString
@Override
public String toString() {
return "ActiveUser{" +
"user=" + user +
", index=" + index +
", credit='" + credit + '\'' +
'}';
}
}User:
public class User implements Serializable {
//成员变量
private String UID;//用户编号
private int password;//密码
private String name;//姓名
private int age;//年龄
private String gender;//性别
private String telNumber;//电话
private String schoolName;//院系
private String date;//注册日期
private UserAccount userAccount;//普通账户信息
//构造方法
//管理账户注册
public User(String UID, int password, String name, int age, String gender, String telNumber, String schoolName, String date) {
this.UID = UID;
this.password = password;
this.name = name;
this.age = age;
this.gender = gender;
this.telNumber = telNumber;
this.schoolName = schoolName;
this.date = date;
}
//普通用户注册
public User(String UID, int password, String name, int age, String gender, String telNumber, String schoolName, String date, UserAccount userAccount) {
this.UID = UID;
this.password = password;
this.name = name;
this.age = age;
this.gender = gender;
this.telNumber = telNumber;
this.schoolName = schoolName;
this.date = date;
this.userAccount = userAccount;
}
//get/set方法
public String getUID() {
return UID;
}
public void setUID(String UID) {
this.UID = UID;
}
public int getPassword() {
return password;
}
public void setPassword(int password) {
this.password = password;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getTelNumber() {
return telNumber;
}
public void setTelNumber(String telNumber) {
this.telNumber = telNumber;
}
public String getSchoolName() {
return schoolName;
}
public void setSchoolName(String schoolName) {
this.schoolName = schoolName;
}
public String getDate() {
return date;
}
public void setDate(String date) {
this.date = date;
}
public UserAccount getUserAccount() {
return userAccount;
}
public void setUserAccount(UserAccount userAccount) {
this.userAccount = userAccount;
}
@Override
public String toString() {
return UID + "\t" + name + "\t\t" + age + "\t\t" + gender + "\t\t" + userAccount + "\t";
}
}
UserAccount:
public class UserAccount implements Serializable {
//成员变量
private String ACID;//账户编号
private int credit_rating;//信用等级
private int balance;//余额
//构造器
public UserAccount(String ACID, int credit_rating, int balance) {
this.ACID = ACID;
this.credit_rating = credit_rating;
this.balance = balance;
}
public String getACID() {
return ACID;
}
public void setACID(String ACID) {
this.ACID = ACID;
}
public int getCredit_rating() {
return credit_rating;
}
public void setCredit_rating(int credit_rating) {
this.credit_rating = credit_rating;
}
public int getBalance() {
return balance;
}
public void setBalance(int balance) {
this.balance = balance;
}
//toString重写
@Override
public String toString() {
return balance+"\t\t";
}
}Job:
public class Job implements Serializable {
private String JID;//营业执照编号
private String company_name;//公司名字
private String job_name;//岗位名称
private JobType jobType_name;//兼职类型
private String job_level;//兼职等级
private String job_content;//工作内容
private int job_demand;//人员数量需求
private long job_time;//工作时间
//构造器
public Job(String JID, String company_name, String job_name, JobType jobType_name, String job_level, String job_content, int job_demand) {
this.JID = JID;
this.company_name = company_name;
this.job_name = job_name;
this.jobType_name = jobType_name;
this.job_level = job_level;
this.job_content = job_content;
this.job_demand = job_demand;
}
public Job(String JID, String company_name, String job_name, JobType jobType_name, String job_level, String job_content, int job_demand, long job_time) {
this.JID = JID;
this.company_name = company_name;
this.job_name = job_name;
this.jobType_name = jobType_name;
this.job_level = job_level;
this.job_content = job_content;
this.job_demand = job_demand;
this.job_time = job_time;
}
//get/set方法
public String getJID() {
return JID;
}
public void setJID(String JID) {
this.JID = JID;
}
public String getCompany_name() {
return company_name;
}
public void setCompany_name(String company_name) {
this.company_name = company_name;
}
public String getJob_name() {
return job_name;
}
public void setJob_name(String job_name) {
this.job_name = job_name;
}
public JobType getJobType_name() {
return jobType_name;
}
public void setJobType_name(JobType jobType_name) {
this.jobType_name = jobType_name;
}
public String getJob_level() {
return job_level;
}
public void setJob_level(String job_level) {
this.job_level = job_level;
}
public String getJob_content() {
return job_content;
}
public void setJob_content(String job_content) {
this.job_content = job_content;
}
public int getJob_demand() {
return job_demand;
}
public void setJob_demand(int job_demand) {
this.job_demand = job_demand;
}
public long getJob_time() {
return job_time;
}
public void setJob_time(long job_time) {
this.job_time = job_time;
}
}JobType:
public class JobType implements Serializable {
private int salary;//工资
private int deduct_salary;//逾期费用扣除比例
private int jTID;//兼职类型编号
private String jobType;//兼职类型名称
//构造器
public JobType(int salary, int deduct_salary, int jTID, String jobType) {
this.salary = salary;
this.deduct_salary = deduct_salary;
this.jTID = jTID;
this.jobType = jobType;
}
//get/set方法
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public int getDeduct_salary() {
return deduct_salary;
}
public void setDeduct_salary(int deduct_salary) {
this.deduct_salary = deduct_salary;
}
public int getJjTID() {
return jTID;
}
public void setJjTID(int jjTID) {
jTID = jjTID;
}
public String getJobType() {
return jobType;
}
public void setJobType(String jobType) {
this.jobType = jobType;
}
}ApplyJob:
public class ApplyJob implements Serializable {
private String UID;//学号
private int jTID;//营业执照编号
private long work_start;//开始时间
private long work_end;//结束时间
//构造器
public ApplyJob(String UID, int jTID, long work_start) {
this.UID = UID;
this.jTID = jTID;
this.work_start = work_start;
}
public ApplyJob(String UID, int jTID, long work_start, long work_end) {
this.UID = UID;
this.jTID = jTID;
this.work_start = work_start;
this.work_end = work_end;
}
//使用get/set方法
public String getUID() {
return UID;
}
public void setUID(String UID) {
this.UID = UID;
}
public int getjTID() {
return jTID;
}
public void setjTID(int jTID) {
this.jTID = jTID;
}
public long getWork_start() {
return work_start;
}
public void setWork_start(long work_start) {
this.work_start = work_start;
}
public long getWork_end() {
return work_end;
}
public void setWork_end(long work_end) {
this.work_end = work_end;
}
}系统功能：
JobEnter:
public class JobEnter {//兼职信息录入功能
//录入兼职信息
public void jobTotalEnter() throws IOException, ClassNotFoundException {
ArrayList<Job> jobList = getJobList();//获得兼职列表信息
while (true) {
boolean isFlag = true;//旗帜判断公司的名称与公司营业执照编号是否一致
System.out.print("需要录入兼职的公司营业执照编号:");//营业执照编号
String JID = TSUtility.readKeyBoard(20, false);
System.out.print("需要录入兼职公司的公司名称:");//公司名称
String company_name = TSUtility.readKeyBoard(15, false);
for (Job j : jobList) {//遍历兼职列表
if (j.getJID().equals(JID)) {//如果输入的公司营业执照编号与列表中的对应
if (!(j.getCompany_name().equals(company_name))) {//如果公司名称与该列表中对应的营业执照编号中的不匹配
System.out.println("该营业执照所持有的公司与你所输入的公司名称不符合请重新输入");
isFlag = false;//把isFlag变为false不执行羡下面的操作
}
}
}
if (isFlag) {//如果营业执照编号和公司对应了执行以下
System.out.print("需要录入的兼职岗位名称:");//岗位名称
String job_name = TSUtility.readKeyBoard(8, false);
while (true) {//使用死循环
System.out.print("需要录入的兼职设置兼职等级(一、二、三、四、五，总共五个等级):");//兼职等级
String job_level = TSUtility.readKeyBoard(1, false);
//判断输入的兼职等级格式有没有符合
if (job_level.equals("一") || job_level.equals("二") || job_level.equals("三") || job_level.equals("四") || job_level.equals("五")) {
System.out.print("需要录入的兼职说明工作内容:");//工作内容
String job_content = TSUtility.readKeyBoard(20, false);
System.out.print("该岗位需要多少工作人员:");//工作人员数量
int job_demand = TSUtility.readstock(3);
System.out.print("请输入该岗位预计会获得多少工资:");//工资
int salary = TSUtility.readstock(4);
System.out.print("请输入每逾期一秒将扣除多少费用:");//逾期费用扣除比例
int deduct_salary = TSUtility.readstock(3);
System.out.print("请输入该兼职属于什么类型:");//兼职类型名称
String jobType = TSUtility.readKeyBoard(8, false);
while (true) {
System.out.print("请为该此兼职任务设置编号:");//兼职类型编号
int jTID = TSUtility.readstock(3);
boolean isTID = true;
for (Job j : jobList) {
if (j.getJobType_name().getJjTID() == jTID) {//判断输入的编号是否已经存在
System.out.println("你输入的编号已经存在，请重新输入");
isTID =false;
break;
}
}
if (isTID) {
//用上面的数据创建对应的Job类型的新兼职信息
Job newJob = new Job(JID, company_name, job_name, new JobType(salary, deduct_salary, jTID, jobType), job_level, job_content, job_demand);
jobList.add(newJob);//把新创建的兼职信息放入兼职列表中
setJobList(jobList);//存放兼职列表信息
return;//结束方法
}
}
} else {//如果兼职等级格式不正确
System.out.println("你输入的兼职等级格式不正确，请重新输入");
}
}
}
}
}
//兼职人员设置
public void setJobPerson() throws IOException, ClassNotFoundException {
ArrayList<Job> jobList = getJobList();//获得兼职列表集合
System.out.print("请输入你要修改的兼职JTID:");
int jTID= TSUtility.readstock(3);//输入要修改的人员需求
boolean isFlag = false;//设置旗帜判断输入的JTID是否在集合中
for (Job j : jobList){//遍历兼职列表集合
if (jTID == j.getJobType_name().getJjTID()){//找到与输入的JTID相符的兼职信息
isFlag = true;//把旗帜改为true使能存放新的数据能进行
System.out.print("请输入你要修改的人员数量:");
int demand = TSUtility.readstock(3);//输入人员需求
j.setJob_demand(demand);//修改人员需求
}
}
if (isFlag){//找到了对应的JTID进行的下一步
setJobList(jobList);//存入数据
System.out.println("修改成功");
}else {//未找到
System.out.println("未找到该JTID兼职信息");
}
}
//兼职金额设置
public void setJobSalary() throws IOException, ClassNotFoundException {
ArrayList<Job> jobList = getJobList();//获得兼职列表集合
System.out.print("请输入你要修改的兼职JTID:");
int jTID= TSUtility.readstock(3);//输入要修改的人员需求
boolean isFlag = false;//设置旗帜判断输入的JTID是否在集合中
for (Job j : jobList){//遍历兼职列表集合
if (jTID == j.getJobType_name().getJjTID()){//找到与输入的JTID相符的兼职信息
isFlag = true;//把旗帜改为true使能存放新的数据能进行
System.out.print("请输入你要将工资设置为:");
int salary = TSUtility.readstock(4);//输入工资
j.getJobType_name().setSalary(salary);//修改工资
}
}
if (isFlag){//找到了对应的JTID进行的下一步
setJobList(jobList);
System.out.println("修改成功");
}else {//未找到
System.out.println("未找到该JTID兼职信息");
}
}
//兼职时间设置
public void setJobTime() throws IOException, ClassNotFoundException {
ArrayList<Job> jobList = getJobList();//获得兼职列表集合
System.out.print("请输入你要修改的兼职JTID:");
int jTID= TSUtility.readstock(3);//输入要修改的人员需求
boolean isFlag = false;//设置旗帜判断输入的JTID是否在集合中
for (Job j : jobList){//遍历兼职列表集合
if (jTID == j.getJobType_name().getJjTID()){//找到与输入的JTID相符的兼职信息
isFlag = true;//把旗帜改为true使能存放新的数据能进行
System.out.print("请输入你要将工作时间设置为:");
long Time =(long) TSUtility.readstock(6);//输入设置的时间
j.setJob_time(Time);//设置工作时间
//j.setJob_time(Time*1000*3600*24);//设置工作时间
}
}
if (isFlag){//找到了对应的JTID进行的下一步
setJobList(jobList);
System.out.println("修改成功");
}else {//未找到
System.out.println("未找到该JTID兼职信息");
}
}
//获得兼职列表信息
public ArrayList<Job> getJobList() throws IOException, ClassNotFoundException {
//反序列化对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\JobMessage.txt"));
ArrayList<Job> jobList = (ArrayList<Job>) in.readObject();//读取兼职列表信息
in.close();//释放资源
return jobList;//返回兼职列表集合
}
//保存兼职列表信息
public void setJobList(ArrayList<Job> jobList) throws IOException {
//序列化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\JobMessage.txt"));
out.writeObject(jobList);//把新的用户列表放入对应的文件
out.close();//释放资源
}
//兼职列表展示
public void showJobList() throws IOException, ClassNotFoundException {
ArrayList<Job> jobList = getJobList();
for (Job j : jobList) {
if (j.getJob_time() != 0) {
System.out.println(j.getJID() + "\t\t\t\t" + j.getCompany_name() + "\t\t" + j.getJob_name() + "\t\t" + j.getJob_content() + "\t\t" + j.getJob_demand() + "\t\t\t\t" + j.getJob_time() + "\t\t\t" + j.getJobType_name().getJjTID() + "\t\t\t\t" + j.getJobType_name().getSalary());
}else {
System.out.println(j.getJID() + "\t\t\t\t" + j.getCompany_name() + "\t\t" + j.getJob_name() + "\t\t" + j.getJob_content() + "\t\t" + j.getJob_demand() + "\t\t\t\t" + "未录入" + "\t\t\t" + j.getJobType_name().getJjTID() + "\t\t\t\t" + j.getJobType_name().getSalary());
}
}
}
}JobFunction:
public class JobFunction {
//查询所有职位信息
public void lookJobAll() throws IOException, ClassNotFoundException {
ArrayList<Job> jobList = getJobList();//使用getJobList获得兼职信息列表集合
for (Job j : jobList) {//遍历集合
System.out.println("" + j.getCompany_name() + "\t\t\t" + j.getJobType_name().getJjTID() + "\t\t\t" + j.getJob_name() + "\t\t" + j.getJob_demand() + "\t\t\t\t" + j.getJob_time() + "\t\t" + j.getJob_content() + "\t\t\t\t\t" + j.getJob_level() + "\t\t" + j.getJobType_name().getSalary() + "\t\t" + j.getJobType_name().getDeduct_salary());
}
}
//查询可申请职位信息
public void lookCanGetJob(ActiveUser activeUser) throws IOException, ClassNotFoundException {
ArrayList<Job> jobList = getJobList();//使用getJobList获得兼职信息列表集合
String credit = activeUser.getCredit();//得到当前账户的信用等级
for (Job j : jobList) {//遍历兼职信息列表集合
if (credit.equals("极差")) {//极差显示等级一的任务
if (j.getJob_level().equals("一")) {//极差只能接等级为一的任务
System.out.println("" + j.getCompany_name() + "\t\t\t" + j.getJobType_name().getJjTID() + "\t\t\t" + j.getJob_name() + "\t\t" + j.getJob_demand() + "\t\t\t\t" + j.getJob_time() + "\t\t" + j.getJob_content() + "\t\t\t\t\t" + j.getJob_level() + "\t\t" + j.getJobType_name().getSalary() + "\t\t" + j.getJobType_name().getDeduct_salary());
}
} else if (credit.equals("较差")) {//较差显示等级一、二的任务
if (j.getJob_level().equals("一") || j.getJob_level().equals("二")) {//较差只能接等级为一、二的任务
System.out.println("" + j.getCompany_name() + "\t\t\t" + j.getJobType_name().getJjTID() + "\t\t\t" + j.getJob_name() + "\t\t" + j.getJob_demand() + "\t\t\t\t" + j.getJob_time() + "\t\t" + j.getJob_content() + "\t\t\t\t\t" + j.getJob_level() + "\t\t" + j.getJobType_name().getSalary() + "\t\t" + j.getJobType_name().getDeduct_salary());
}
} else if (credit.equals("良好")) {//良好显示等级一、二、三的任务
if (j.getJob_level().equals("一") || j.getJob_level().equals("二") || j.getJob_level().equals("三")) {//良好只能接等级为一、二、三的任务
System.out.println("" + j.getCompany_name() + "\t\t\t" + j.getJobType_name().getJjTID() + "\t\t\t" + j.getJob_name() + "\t\t" + j.getJob_demand() + "\t\t\t\t" + j.getJob_time() + "\t\t" + j.getJob_content() + "\t\t\t\t\t" + j.getJob_level() + "\t\t" + j.getJobType_name().getSalary() + "\t\t" + j.getJobType_name().getDeduct_salary());
}
} else if (credit.equals("优秀")) {//优秀显示等级一、二、三、四的任务
if (j.getJob_level().equals("一") || j.getJob_level().equals("二") || j.getJob_level().equals("三") || j.getJob_level().equals("四")) {//优秀只能接等级为一、二、三、四的任务
System.out.println("" + j.getCompany_name() + "\t\t\t" + j.getJobType_name().getJjTID() + "\t\t\t" + j.getJob_name() + "\t\t" + j.getJob_demand() + "\t\t\t\t" + j.getJob_time() + "\t\t" + j.getJob_content() + "\t\t\t\t\t" + j.getJob_level() + "\t\t" + j.getJobType_name().getSalary() + "\t\t" + j.getJobType_name().getDeduct_salary());
}
} else if (credit.equals("极优")) {//极优显示等级一、二、三、四、五的任务
if (j.getJob_level().equals("一") || j.getJob_level().equals("二") || j.getJob_level().equals("三") || j.getJob_level().equals("四") || j.getJob_level().equals("五")) {//极优只能接等级为一、二、三、四、五的任务
System.out.println("" + j.getCompany_name() + "\t\t\t" + j.getJobType_name().getJjTID() + "\t\t\t" + j.getJob_name() + "\t\t" + j.getJob_demand() + "\t\t\t\t" + j.getJob_time() + "\t\t" + j.getJob_content() + "\t\t\t\t\t" + j.getJob_level() + "\t\t" + j.getJobType_name().getSalary() + "\t\t" + j.getJobType_name().getDeduct_salary());
}
} else {//信用比极差还低的用户无法接到任务
System.out.println("你的信用等级太低无法为你找到任何适合你的工作");
break;
}
}
}
//职位申请
public void applyJob(ActiveUser activeUser) throws IOException, ClassNotFoundException {
ArrayList<Job> jobList = getJobList();//使用getJobList获得兼职信息列表集
System.out.print("请输入你要申请的职位JTID:");
int jTID = TSUtility.readstock(3);//输入你想申请的职位的JTID
boolean isFlag = false;//做旗帜判断有没有该JTID的兼职信息
boolean judge = true;
for (Job j : jobList) {//遍历兼职信息列表
if (j.getJobType_name().getJjTID() == jTID) {//找到了对应的JTID信息列表
boolean isLevel = false;//判断等级是否足够
//判断等级
if (activeUser.getCredit().equals("极优")) {
isLevel = true;
} else if (activeUser.getCredit().equals("优秀")) {
if (j.getJob_level().equals("四") || j.getJob_level().equals("三") || j.getJob_level().equals("二") || j.getJob_level().equals("一")) {
isLevel = true;
}
} else if (activeUser.getCredit().equals("良好")) {
if (j.getJob_level().equals("三") || j.getJob_level().equals("二") || j.getJob_level().equals("一")) {
isLevel = true;
}
} else if (activeUser.getCredit().equals("较差")) {
if (j.getJob_level().equals("二") || j.getJob_level().equals("一")) {
isLevel = true;
}
} else if (activeUser.getCredit().equals("极差")) {
if (j.getJob_level().equals("一")) {
isLevel = true;
}
}else {
isLevel = false;
}
if (isLevel) {//如果等级足够
if (j.getJob_demand() > 0) {//如果该兼职人员还未满
j.setJob_demand(j.getJob_demand() - 1);//职位人数少一
Date date = new Date();//创建Date对象
long time = date.getTime();//获得当前时间
ApplyJob applyJob = new ApplyJob(activeUser.getUser().getUID(), jTID, time);//创建新的ApplyJob对象
judge = setApplyJob(applyJob);//使用setApplyJob通过ApplyJob对象保存到已经申请职位列表中,获得返回值判断是否申请了同一个兼职
if (judge) {//如果是true说明没有
isFlag = true;//使旗帜为true能进行下一步
}
} else {//该兼职人员已满
System.out.println("该兼职人员已满");
return;
}
}else {
System.out.println("你的等级不够");
return;
}
}
}
if (judge) {
if (isFlag) {//说明申请成功
setJobList(jobList);//因为兼职申请成功需求人数要减1
System.out.println("申请成功");
} else {//说明没有申请成功，因为没有找到对应的JTID
System.out.println("输入的JTID未找到");
}
} else {//说明已经申请过一次了
System.out.println("一个人不能接同一个任务两次");
}
}
//结束任务
public void endJob(ActiveUser activeUser) throws IOException, ClassNotFoundException {
ArrayList<ApplyJob> applyJob = getApplyJob();//通过getApplyJob获得已申请兼职列表集合
boolean isFlag = false;//做旗帜判断
if (applyJob != null) {//如果得到的已申请兼职列表不为null
System.out.print("请输入你要结束的任务的兼职职位JTID:");
int jTID = TSUtility.readstock(3);//输入你要结束任务的兼职职位JTID
for (ApplyJob a : applyJob) {//遍历已申请兼职列表
if (a.getUID().equals(activeUser.getUser().getUID())) {//如果列表中的UID与当前用户的UID一致
if (a.getjTID() == jTID) {//如果输入的JTID与列表中的JTID符合
if (a.getWork_end() == 0) {//如果任务未结束
Date date = new Date();//创建Date对象
long end_time = date.getTime();//得到当前结束的时间
a.setWork_end(end_time);//设置结束时间
long useTime = a.getWork_end() - a.getWork_start();//计算实际运用的时间
ArrayList<Job> jobList = getJobList();//使用getJobList获得兼职信息列表集
for (Job j : jobList) {//遍历兼职信息列表
if (j.getJobType_name().getJjTID() == jTID) {//如果输入的JTID与兼职信息列表中的JTID符合
if (useTime > j.getJob_time()) {//如果该兼职的任务时间小于实际时间，那就是逾期
long deduct_salary = (useTime - j.getJob_time()) * j.getJobType_name().getDeduct_salary();//得到逾期要扣除的钱
//得到最后的余额情况
int balance = (int) (j.getJobType_name().getSalary() - deduct_salary) + activeUser.getUser().getUserAccount().getBalance();
if (balance <= 0) {//如果余额小于等于0
activeUser.getUser().getUserAccount().setBalance(0);//使余额为0
} else {//如果不是
activeUser.getUser().getUserAccount().setBalance(balance);//使余额等于balance
}
if (activeUser.getUser().getUserAccount().getCredit_rating() > 0) {//最低就到-3
int rating = activeUser.getUser().getUserAccount().getCredit_rating() - 3;//因为逾期要扣除信用系数
activeUser.getUser().getUserAccount().setCredit_rating(rating);//当前用户的信用系数扣除
}
//重新设置当前用户的信用等级
setCredit(activeUser);
} else {//如果该兼职的任务时间大于等于实际时间，那就是正常
int balance = activeUser.getUser().getUserAccount().getBalance() + j.getJobType_name().getSalary();//增加后的余额
activeUser.getUser().getUserAccount().setBalance(balance);//余额增加
if (activeUser.getUser().getUserAccount().getCredit_rating() < 15) {//设置最高就到15
int rating = activeUser.getUser().getUserAccount().getCredit_rating() + 1;//因为未逾期信用系数加一
activeUser.getUser().getUserAccount().setCredit_rating(rating);//当前用户的信用系数增加
}
//重新设置当前用户的信用等级
setCredit(activeUser);
}
setUser(activeUser);//把用户的信息从新保存
isFlag = true;
}
}
} else {//如果任务结束
System.out.println("该任务已经结束");
}
} else {//如果没有找到可能存在JTID输入错误或者是没有申请该任务
System.out.println("你输入的JTID有误，亦或者是你并没有申请该任务");
}
}
}
if (isFlag) {//说明任务结束按钮成功
setApplyJob(applyJob);//通过集合保存到已经申请职位列表中
System.out.println("任务结束");
}
} else {//如果得到的已申请兼职列表为null
System.out.println("当前没有人申请兼职");
}
}
//查询已完成兼职
public void endTimeJob(ActiveUser activeUser) throws IOException, ClassNotFoundException {
ArrayList<ApplyJob> applyJob = getApplyJob();//通过getApplyJob获得已申请兼职列表集合
ArrayList<Job> jobList = getJobList();//获得兼职信息列表集合
for (ApplyJob a : applyJob) {//遍历已申请兼职列表集合
if (a.getUID().equals(activeUser.getUser().getUID())) {//符合当前用户时进入
if (a.getWork_end() != 0) {//说明任务已经完成
for (Job j : jobList) {//遍历兼职信息列表集合
if (j.getJobType_name().getJjTID() == a.getjTID()) {//展示该对应的JTID的兼职信息
System.out.println("" + j.getCompany_name() + "\t\t\t" + j.getJobType_name().getJjTID() + "\t\t\t" + j.getJob_name() + "\t\t" + j.getJob_demand() + "\t\t\t\t" + j.getJob_time() + "\t\t" + j.getJob_content() + "\t\t\t\t\t" + j.getJob_level() + "\t\t" + j.getJobType_name().getSalary() + "\t\t" + j.getJobType_name().getDeduct_salary());
}
}
}
}
}
}
//查询正在兼职信息
public void runningJob(ActiveUser activeUser) throws IOException, ClassNotFoundException {
ArrayList<ApplyJob> applyJob = getApplyJob();//通过getApplyJob获得已申请兼职列表集合
ArrayList<Job> jobList = getJobList();//获得兼职信息列表集合
for (ApplyJob a : applyJob) {//遍历已申请兼职列表集合
if (a.getUID().equals(activeUser.getUser().getUID())) {//符合当前用户时进入
if (a.getWork_end() == 0) {//说明任务未完成
for (Job j : jobList) {//遍历兼职信息列表集合
if (j.getJobType_name().getJjTID() == a.getjTID()) {//展示该对应的JTID的兼职信息
System.out.println("" + j.getCompany_name() + "\t\t\t" + j.getJobType_name().getJjTID() + "\t\t\t" + j.getJob_name() + "\t\t" + j.getJob_demand() + "\t\t\t\t" + j.getJob_time() + "\t\t" + j.getJob_content() + "\t\t\t\t\t" + j.getJob_level() + "\t\t" + j.getJobType_name().getSalary() + "\t\t" + j.getJobType_name().getDeduct_salary());
}
}
}
}
}
}
//实时更新
public void setUser(ActiveUser activeUser) throws IOException, ClassNotFoundException {
//读取用户列表
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\UserList.txt"));
ArrayList<User> arr = (ArrayList<User>) in.readObject();//得到的用户列表
in.close();//释放资源
//把当前用户修改后的用户信息放入列表
arr.set(activeUser.getIndex(), activeUser.getUser());
//把修改后的用户列表存入文件中
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\UserList.txt"));
out.writeObject(arr);//放入文件
out.close();//释放资源
}
//通过集合保存到已经申请职位列表中
public void setApplyJob(ArrayList<ApplyJob> applyJob) throws IOException, ClassNotFoundException {
//序列化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\ApplyJobList.txt"));
out.writeObject(applyJob);//把集合存入文件
out.close();//释放资源
}
//通过ApplyJob保存到已经申请职位列表中
public boolean setApplyJob(ApplyJob applyJob) throws IOException, ClassNotFoundException {
//使用反序列化对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\ApplyJobList.txt"));
ArrayList<ApplyJob> arrayList = (ArrayList<ApplyJob>) in.readObject();//获得对应的文件集合
in.close();//释放资源
boolean isFlag = true;//设置旗帜
for (ApplyJob a : arrayList) {//遍历已申请兼职的列表
if (a.getUID().equals(applyJob.getUID())) {//找到符合的UID
if (a.getjTID() == applyJob.getjTID()) {//如果UID和JTID都相同说明是同一个人接受同一个兼职信息
isFlag = false;//选择不保存该申请
break;//结束循环
}
}
}
if (isFlag) {//申请接受
arrayList.add(applyJob);//该次申请加入申请兼职列表
//序列化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\ApplyJobList.txt"));
out.writeObject(arrayList);//写入文件
out.close();//释放资源
}
return isFlag;
}
//获得已申请列表集合
public ArrayList<ApplyJob> getApplyJob() throws IOException, ClassNotFoundException {
//反序列化对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\ApplyJobList.txt"));
ArrayList<ApplyJob> arrayList = (ArrayList<ApplyJob>) in.readObject();//读取申请兼职列表
in.close();//释放资源
return arrayList;//返回申请兼职列表
}
//获得兼职信息列表集合
public ArrayList<Job> getJobList() throws IOException, ClassNotFoundException {
//反序列化对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\JobMessage.txt"));
ArrayList<Job> jobList = (ArrayList<Job>) in.readObject();//读取兼职信息列表
in.close();//释放资源
return jobList;//返回兼职信息列表
}
//保存兼职信息列表
public void setJobList(ArrayList<Job> jobList) throws IOException, ClassNotFoundException {
//序列化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\JobMessage.txt"));
out.writeObject(jobList);//把当前集合从新写入文件
out.close();//释放资源
}
//重新设置当前用户的信用等级
public void setCredit(ActiveUser activeUser) {
int credit_rating = activeUser.getUser().getUserAccount().getCredit_rating();//获得当前账户的信用系数
if (credit_rating >= 0 && credit_rating < 3) {//极差系数
activeUser.setCredit("极差");
} else if (credit_rating >= 3 && credit_rating < 6) {//较差系数
activeUser.setCredit("较差");
} else if (credit_rating >= 6 && credit_rating < 9) {//良好系数
activeUser.setCredit("良好");
} else if (credit_rating >= 9 && credit_rating < 12) {//优秀系数
activeUser.setCredit("优秀");
} else if (credit_rating >= 12) {//极优系数
activeUser.setCredit("极优");
} else {//信用比极差还低无发找兼职
activeUser.setCredit("无");
}
}
}Management:
public class Management {//系统管理
//删除
//删除账户
public void delEnter() throws IOException, ClassNotFoundException {
System.out.print("请输入你要删除账户的UID:");
String UID = TSUtility.readKeyBoard(10, false);//输入要删除的账户UID
HashMap<String, String> map = getEnter();//通过getEnter得到录入账户的列表
Set<String> key = map.keySet();//得到键的集合
boolean isEnter = false;
for (String k : key) {//遍历键的集合
if (k.equals(UID)) {//找到对应的UID
isEnter = true;
break;
}
}
if (isEnter) {//找到对应的UID
map.remove(UID);//删除账户
setEnter(map);//保存新的录入列表
//判断输入的UID是否已经注册
ArrayList<User> userList = getUser();//得到对应的用户列表信息
boolean isUser = false;//判断是否要删除的UID已经注册
int index = 0; //用来保存要删除的索引
for (int x = 0; x < userList.size(); x++) {//遍历用户列表
if (userList.get(x).getUID().equals(UID)) {//找到对应的UID，说明已经注册
isUser = true;//旗帜变为true，执行下一步
index = x;//保存对应的索引
break;
}
}
if (isUser) {//如果找到执行下面
userList.remove(index);//根据索引删除用户
setUser(userList);//保存新的用户列表
//判断输入的UID是否有申请的兼职
ArrayList<ApplyJob> applyJobs = getApply();//获得申请列表
boolean isApply = false;//判断是否有该注册账户申请的兼职
ArrayList<Integer> indexList = new ArrayList<Integer>();//因为用户可能申请了很多兼职，就要存很多索引
for (int x = 0; x < applyJobs.size(); x++) {//遍历申请列表
if (applyJobs.get(x).getUID().equals(UID)) {//如果UID和申请列表中的一致
isApply = true;//旗帜为true
indexList.add(x);//把对应的索引存到索引集合
}
}
if (isApply) {//有存在该用户申请的职位
for (Integer i : indexList) {//遍历缩影集合
applyJobs.remove(i);//删除对应缩影的申请请求
}
setApply(applyJobs);
System.out.println("删除完毕");//删除完毕
}
} else {
System.out.println("删除结束");
return;//没有找到结束该方法
}
} else {//没有找到对应的UID
System.out.println("未找到对应的账户");
}
}
//删除用户
public void delUser() throws IOException, ClassNotFoundException {
System.out.print("请输入你要删除用户的UID:");
String UID = TSUtility.readKeyBoard(10, false);
ArrayList<User> userList = getUser();//得到对应的用户列表信息
ArrayList<ApplyJob> applyJobs = getApply();//得到申请列表
boolean isRun = false;//判断是否有在在执行的任务
boolean isUser = false;//判断要删除的UID是否已经注册
int index = 0; //用来保存要删除的索引
for (ApplyJob a : applyJobs) {
if (a.getUID().equals(UID)) {
if (a.getWork_end() != 0) {
for (int x = 0; x < userList.size(); x++) {//遍历用户列表
if (userList.get(x).getUID().equals(UID)) {//找到对应的UID，说明已经注册
isUser = true;//旗帜变为true，执行下一步
isRun = true;//旗帜变为true，表示可以进行下一步
index = x;//保存对应的索引
}
}
} else {
System.out.println("当前用户有正在执行的兼职无法删除");
return;
}
} else {
for (int x = 0; x < userList.size(); x++) {//遍历用户列表
if (userList.get(x).getUID().equals(UID)) {//找到对应的UID，说明已经注册
isUser = true;//旗帜变为true，执行下一步
isRun = true;//旗帜变为true，表示可以进行下一步
index = x;//保存对应的索引
}
}
}
}
if (isRun) {
if (isUser) {//如果找到执行下面
userList.remove(index);//根据索引删除用户
setUser(userList);//保存新的用户列表
boolean isApply = false;//判断是否有该注册账户申请的兼职
ArrayList<Integer> indexList = new ArrayList<Integer>();//因为用户可能申请了很多兼职，就要存很多索引
for (int x = 0; x < applyJobs.size(); x++) {//遍历申请列表
if (applyJobs.get(x).getUID().equals(UID)) {//如果UID和申请列表中的一致
isApply = true;//旗帜为true
indexList.add(x);//把对应的索引存到索引集合
}
}
if (isApply) {//有存在该用户申请的职位
for (Integer i : indexList) {//遍历缩影集合
applyJobs.remove(i);//删除对应缩影的申请请求
}
setApply(applyJobs);
System.out.println("删除完毕");//删除完毕
}
} else {
System.out.println("未找到对应的UID");
}
}
}
//兼职信息删除
public void delJob() throws IOException, ClassNotFoundException {
System.out.print("请输入你要删除兼职的JTID:");
int jTID = TSUtility.readstock(3);//获得要删除的JTID
ArrayList<Job> jobList = getJob();//得到兼职信息列表
ArrayList<ApplyJob> applyJobs = getApply();//得到申请列表
boolean isRun = false;//判断是否有在在执行的任务
boolean isJob = false;//给出旗帜判断输入的JTID是否存在
int index = 0;//对应要删除JTID的索引
for (ApplyJob a : applyJobs) {
if (a.getjTID() == jTID) {
if (a.getWork_end() != 0) {
for (int x = 0; x < jobList.size(); x++) {//遍历兼职信息列表
if (jobList.get(x).getJobType_name().getJjTID() == jTID) {//找到对应的JTID
isRun = true;
isJob = true;//旗帜为true
index = x;//保存对应的缩影
}
}
} else {
System.out.println("当前兼职有用户正在执行无法删除");
return;
}
} else {
for (int x = 0; x < jobList.size(); x++) {//遍历兼职信息列表
if (jobList.get(x).getJobType_name().getJjTID() == jTID) {//找到对应的JTID
isRun = true;
isJob = true;//旗帜为true
index = x;//保存对应的缩影
}
}
}
}
if (isRun) {
if (isJob) {//如果找到对应的JTID
jobList.remove(index);//根据保存的索引删除兼职信息
setJob(jobList);//保存更新后的兼职信息列表
ArrayList<Integer> indexList = new ArrayList<Integer>();//因为用户可能申请了很多兼职，就要存很多索引
boolean isApply = false;//判断是否有对应的申请兼职
for (int x = 0; x < applyJobs.size(); x++) {//遍历申请兼职列表
if (applyJobs.get(x).getjTID() == jTID) {//如果在申请兼职列表中找到对应的JTID,说明有对应的申请兼职
isApply = true;//旗帜改为true
indexList.add(x);//把对应的索引存入索引集合中
}
}
if (isApply) {//如果有对应的申请信息
for (Integer i : indexList) {//遍历索引集合
applyJobs.remove(i);//根据对应的索引删除对应的申请信息
}
setApply(applyJobs);//保存最新的申请兼职列表
System.out.println("删除完毕");
} else {//没有对应的申请信息
System.out.println("删除完毕");
return;//结束该方法
}
} else {//没有找到对应的JTID
System.out.println("未找到对应的JTID");
}
}
}
//
//添加
//添加账户
public void addEnter() throws IOException, ClassNotFoundException {
System.out.print("请输入学生或老师的姓名:");
String name = TSUtility.readKeyBoard(4, false);//得到姓名
System.out.print("请输入学生的学号或老师的编号:");
String UID = TSUtility.readKeyBoard(10, false);//得到UID
//正则表达式
String regex = "\\w{10}";
StringBuilder U = new StringBuilder();//输入的学号的前半段
Pattern pat = Pattern.compile(regex);
Matcher mat = pat.matcher(UID);
if (mat.matches()) {//使用正则表达式
//记录学号前半段
for (int x = 0; x < 7; x++) {
U = U.append(UID.charAt(x));
}
}
String num = U.toString();//得到的是输入的UID的前半段
boolean isUID = false;//设置旗帜判断前面的7位数是不是对应的格式
if (num.equals("student") || num.equals("teacher")) {//如果前面的7个数是对应的格式则执行
isUID = true;//旗帜为true
} else {//不是对应的格式
System.out.println("你输入的学号或者教师编号格式不正确");
}
if (isUID) {//前面的7位数是对应的格式执行下面
HashMap<String, String> map = getEnter();//得到录入列表
Set<String> key = map.keySet();//得到键也就是录入列表中的UID
boolean isTrue = true;//判断是否执行存入
for (String s : key) {//遍历键值
if (s.equals(UID)) {//如果键值里有相同的UID结束循环不执行存入
System.out.print("你输入的学号或者教师编号已经存在，");
isTrue = false;
}
}
if (isTrue) {//如果执行存入
map.put(UID, name);//把录入的数据存入map集合
setEnter(map);//保存数据
System.out.println("录入成功");
} else {
System.out.println("录入失败");
}
}
}
//添加用户
public void addUser() throws IOException, ClassNotFoundException {
ArrayList<User> userList = getUser();
label:
while (true) {
System.out.println("请输入你的学号/教师编号:");//输入学号或者教师编号
System.out.println("请按以下格式书写(不得超过10位)：");
System.out.println("学号：student+xxx");
System.out.println("教师编号：teacher+xxx");
System.out.print("请输入:");
String UID = TSUtility.readKeyBoard(10, false);
System.out.print("请输入名字:");//姓名
String name = TSUtility.readKeyBoard(4, false);
HashMap<String, String> map = getEnter();
Set<String> set = map.keySet();//得到map集合的键
boolean isEnter = false;//判断是否录入的旗帜
for (String s : set) {//增强for循环
if (UID.equals(s)) {//如果UID与录入的信息匹配
if (name.equals(map.get(s))) {//如果输入的name与录入的信息匹配
isEnter = true;//旗帜为true
break;
}
}
}
if (isEnter) {
for (User u : userList) {
if (u.getUID().equals(UID)) {
System.out.println("请输入录入的学号或者教师编号已经存在");
System.out.println();
continue label;//返回从新输出学号或者教师编号
}
}
StringBuilder U = new StringBuilder();//输入的学号的前半段
StringBuilder A = new StringBuilder();//输入学号的后半段
boolean isFlag = false;//做旗帜
boolean isStudent = false;//普通用户旗帜
boolean isTeacher = false;//管理用户旗帜
//正则表达式
String regex = "\\w{10}";
Pattern pat = Pattern.compile(regex);
Matcher mat = pat.matcher(UID);
if (mat.matches()) {//使用正则表达式
//记录学号前半段
for (int x = 0; x < 7; x++) {
U = U.append(UID.charAt(x));
}
//记录学号后半段
for (int x = 7; x < 10; x++) {
A = A.append(UID.charAt(x));
}
}
//把UID和ACID转为String
String num = U.toString();
String ACID = A.toString();
//判断输入的学号或者教师编号是否符合格式
if (num.equals("student")) {//判断是普通用户
isFlag = true;
isStudent = true;//开启学生旗帜
} else if (num.equals("teacher")) {//判断是管理用户
isFlag = true;
isTeacher = true;//开启老师旗帜
} else {
System.out.println("请输入录入的学号/教师编号不对");
System.out.println();
continue label;//返回从新输入学号或者教师编号
}
if (isFlag) {
System.out.print("请输入密码(密码不超过6位):");//密码
int password = TSUtility.readstock(6);
System.out.print("请输入录入的年龄:");//年龄
int age = TSUtility.readstock(2);
System.out.print("请输入录入的性别:");//性别
String gender = TSUtility.readKeyBoard(2, false);
System.out.print("请输入录入的电话:");//电话
String telNumber = TSUtility.readKeyBoard(11, false);
System.out.print("请输入录入的院系:");//院系
String schoolName = TSUtility.readKeyBoard(20, false);
SimpleDateFormat sim = new SimpleDateFormat("yyyy--MM--dd");//使用SimpleDateFormat，同时给定个格式
Date d = new Date();//创建一个Date对象，该Date对象是创建时的事件
String date = sim.format(d);//记录存入的日期
if (isStudent) {//如果是普通用户
//创建普通用户
User commonUser = new User(UID, password, name, age, gender, telNumber, schoolName, date, new UserAccount(ACID, 6, 0));
userList.add(commonUser);//添加到集合中
setUser(userList);//保存数据
System.out.println("添加成功");
return;
}
if (isTeacher) {//如果是管理用户
//创建管理用户
User administrator = new User(UID, password, name, age, gender, telNumber, schoolName, date);
userList.add(administrator);//添加到集合中
setUser(userList);//保存数据
System.out.println("添加成功");
return;
}
}
} else {//如果注册的信息未被录入
System.out.println("你输入的UID和姓名未被注册，请先录入数据");//给出提示
return;//结束死循环
}
}
}
//修改账户密码
public void modifyPassword() throws IOException, ClassNotFoundException {
System.out.print("请输入你要修改用户的UID:");
String UID = TSUtility.readKeyBoard(10, false);//得到要修改的UID
ArrayList<User> userList = getUser();//得到用户列表
boolean isUID = false;//设置旗帜，如果找到则执行下一步
int original = 0;//原密码
int index = 0;//对应的索引
for (int x = 0; x < userList.size(); x++) {//遍历用户列表
if (userList.get(x).getUID().equals(UID)) {//寻找对应的UID，找到则修改旗帜
isUID = true;//旗帜修改
original = userList.get(x).getPassword();//得到原密码
index = x;//得到索引
break;//结束循环
}
}
if (isUID) {//找到了对应的UID
System.out.print("请输入新密码(回车表示不修改):");
int passWord = TSUtility.readInt(original, 6);//得到新密码
userList.get(index).setPassword(passWord);//修改密码
setUser(userList);//保存新的用户列表
} else {//没有找到对应的UID
System.out.println("未找到对应UID");
}
}
//
//查询
//查询用户
public void lookUserList() throws IOException, ClassNotFoundException {
ArrayList<User> userList = getUser();//得到用户列表
String credit = "";//信用等级
for (User u : userList) {//遍历用户列表
if (u.getUID().charAt(0) == 'c') {//如果是学生
//根据信用系数得到信用等级
if (u.getUserAccount().getCredit_rating() >= 12) {
credit = "极优";
} else if (u.getUserAccount().getCredit_rating() < 12 && u.getUserAccount().getCredit_rating() >= 9) {
credit = "优秀";
} else if (u.getUserAccount().getCredit_rating() < 9 && u.getUserAccount().getCredit_rating() >= 6) {
credit = "良好";
} else if (u.getUserAccount().getCredit_rating() < 6 && u.getUserAccount().getCredit_rating() >= 3) {
credit = "较差";
} else if (u.getUserAccount().getCredit_rating() < 3 && u.getUserAccount().getCredit_rating() >= 0) {
credit = "极差";
} else {
credit = "无";
}
//
System.out.println(u.getUID() + "\t\t" + u.getName() + "\t\t" + u.getAge() + "\t\t" + u.getGender() + "\t\t" + u.getSchoolName() + "\t\t" + u.getTelNumber() + "\t\t" + u.getDate() + "\t\t" + u.getUserAccount().getACID() + "\t\t" + u.getUserAccount().getBalance() + "\t\t" + credit);
} else {//如果是老师
System.out.println(u.getUID() + "\t\t" + u.getName() + "\t\t" + u.getAge() + "\t\t" + u.getGender() + "\t\t" + u.getSchoolName() + "\t\t" + u.getTelNumber() + "\t\t" + u.getDate());
}
}
}
//查询账户
public void lookEnter() throws IOException, ClassNotFoundException {
HashMap<String, String> map = getEnter();//得到录入列表
Set<String> key = map.keySet();//得到键的集合
for (String s : key) {//遍历键的集合
System.out.println(s + "\t\t" + map.get(s));
}
}
//查询已投放职位
public void lookAllJob() throws IOException, ClassNotFoundException {
ArrayList<Job> jobList = getJob();
for (Job j : jobList) {
System.out.println(j.getJobType_name().getJjTID() + "\t\t" + j.getCompany_name() + "\t\t" + j.getJob_level() + "\t\t" + j.getJob_demand() + "\t\t" + j.getJob_time() + "\t\t" + j.getJob_name());
}
}
//查询已完成职位
public void lookEndJob() throws IOException, ClassNotFoundException {
ArrayList<ApplyJob> applyJobs = getApply();//得到申请列表
ArrayList<User> userList = getUser();//得到用户列表
ArrayList<Job> jobList = getJob();//得到兼职列表
String name = "";//姓名
String company_name = "";//公司名称
String job_name = "";//岗位名称
for (ApplyJob a : applyJobs) {//遍历申请列表
if (a.getWork_end() != 0) {
for (User u : userList) {//遍历用户列表
if (a.getUID().equals(u.getUID())) {//找到对应的UID
name = u.getName();//得到对应的姓名
break;
}
}
for (Job j : jobList) {//遍历兼职列表
if (a.getjTID() == j.getJobType_name().getJjTID()) {//找到对应JTID
company_name = j.getCompany_name();//得到公司名称
job_name = j.getJob_name();//得到岗位名称
break;
}
}
System.out.println(name + "\t\t" + company_name + "\t\t" + job_name);
}
}
}
//查询逾期兼职
public void lookOverdue() throws IOException, ClassNotFoundException {
ArrayList<ApplyJob> applyJobs = getApply();//得到申请列表
ArrayList<User> userList = getUser();//得到用户列表
ArrayList<Job> jobList = getJob();//得到兼职列表
String name = "";//姓名
String company_name = "";//公司名称
String job_name = "";//岗位名称
Date date = new Date();//创建Date对象
long nowTime = date.getTime();
for (ApplyJob a : applyJobs) {//遍历申请列表
for (Job j : jobList) {//遍历用户列表
if (a.getjTID() == j.getJobType_name().getJjTID() && nowTime - a.getWork_start() > j.getJob_time()) {//找到对应的JTID,并且查看的时间减去任务开始时间大于工作要求时间的
for (User u : userList) {//遍历用户列表
if (a.getUID().equals(u.getUID())) {//找到对应的UID
name = u.getName();//得到对应的姓名
break;
}
}
company_name = j.getCompany_name();//得到公司名称
job_name = j.getJob_name();//得到岗位名称
System.out.println(name + "\t\t" + company_name + "\t\t" + job_name);
}
}
}
}
//
//获得录入列表
public HashMap<String, String> getEnter() throws IOException, ClassNotFoundException {
//反序列化对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\EnteringList.txt"));
HashMap<String, String> map = (HashMap<String, String>) in.readObject();//读取录入列表
in.close();//释放资源
return map;//返回录入列表
}
//保存录入列表
public void setEnter(HashMap<String, String> map) throws IOException, ClassNotFoundException {
//序列化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\EnteringList.txt"));
out.writeObject(map);//保存录入列表
out.close();//释放资源
}
//获得用户列表
public ArrayList<User> getUser() throws IOException, ClassNotFoundException {
//反序列化对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\UserList.txt"));
ArrayList<User> UserList = (ArrayList<User>) in.readObject();//读取用户列表
in.close();//释放资源
return UserList;//返回用户列表
}
//保存用户列表
public void setUser(ArrayList<User> userList) throws IOException, ClassNotFoundException {
//序列化对像
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\UserList.txt"));
out.writeObject(userList);//保存用户列表
out.close();//释放资源
}
//得到申请列表
public ArrayList<ApplyJob> getApply() throws IOException, ClassNotFoundException {
//反序列化对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\ApplyJobList.txt"));
ArrayList<ApplyJob> applyJobs = (ArrayList<ApplyJob>) in.readObject();//获得申请兼职列表
in.close();//释放资源
return applyJobs;//返回申请列表
}
//保存申请列表
public void setApply(ArrayList<ApplyJob> applyJobs) throws IOException, ClassNotFoundException {
//序列化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\ApplyJobList.txt"));
out.writeObject(applyJobs);//保存新的申请列表
out.close();//释放资源
}
//获得兼职信息列表
public ArrayList<Job> getJob() throws IOException, ClassNotFoundException {
//反序列化对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\JobMessage.txt"));
ArrayList<Job> jobList = (ArrayList<Job>) in.readObject();//读取兼职信息列表
in.close();//释放资源
return jobList;//返回兼职信息列表
}
//保存兼职信息列表
public void setJob(ArrayList<Job> jobList) throws IOException, ClassNotFoundException {
//序列化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\JobMessage.txt"));
out.writeObject(jobList);//保存新的兼职信息列表
out.close();//释放资源
}
}Login:
public class Login {//登录类
//注册功能
public void register() throws IOException, ClassNotFoundException {
//获取已经存在的用户
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\UserList.txt"));
ArrayList<User> arr = (ArrayList<User>) in.readObject();
in.close();//释放登入资源
//旗帜
label:
while (true) {
System.out.println("请输入你的学号/教师编号:");//输入学号或者教师编号
System.out.println("请按以下格式书写(不得超过10位)：");
System.out.println("学号：student+xxx");
System.out.println("教师编号：teacher+xxx");
System.out.print("请输入:");
String UID = TSUtility.readKeyBoard(10, false);
System.out.print("请输入你的名字:");//姓名
String name = TSUtility.readKeyBoard(4, false);
//反序列化对象
ObjectInputStream inEnter = new ObjectInputStream(new FileInputStream("Job\\\\src\\\\File\\\\EnteringList.txt"));
Map<String, String> enter = (Map<String, String>) inEnter.readObject();//得到已经录入的对象集合
inEnter.close();//释放资源
int isEntering = judgeEntering(UID, name, enter);//做旗帜判断输入的数据是否已经录入
if (isEntering == 1) {
for (User u : arr) {
if (u.getUID().equals(UID)) {
System.out.println("你输入的学号或者教师编号已经存在");
System.out.println();
System.out.println("请问你还要重新注册吗(Y/N):");
char judge = TSUtility.readConfirmSelection();
if (judge == 'Y') {
continue label;//返回从新输出学号或者教师编号
}else {
return;
}
}
}
StringBuilder U = new StringBuilder();//输入的学号的前半段
StringBuilder A = new StringBuilder();//输入学号的后半段
boolean isFlag = false;//做旗帜
boolean isStudent = false;//普通用户旗帜
boolean isTeacher = false;//管理用户旗帜
//正则表达式
String regex = "\\w{10}";
Pattern pat = Pattern.compile(regex);
Matcher mat = pat.matcher(UID);
if (mat.matches()) {//使用正则表达式
//记录学号前半段
for (int x = 0; x < 7; x++) {
U = U.append(UID.charAt(x));
}
//记录学号后半段
for (int x = 7; x < 10; x++) {
A = A.append(UID.charAt(x));
}
}
//把UID和ACID转为String
String num = U.toString();
String ACID = A.toString();
//判断输入的学号或者教师编号是否符合格式
if (num.equals("student")) {//判断是普通用户
isFlag = true;
isStudent = true;//开启学生旗帜
} else if (num.equals("teacher")) {//判断是管理用户
isFlag = true;
isTeacher = true;//开启老师旗帜
} else {
System.out.println("你输入的学号/教师编号不对");
System.out.println();
continue label;//返回从新输入学号或者教师编号
}
if (isFlag) {
System.out.print("请输入密码(密码不超过6位):");//密码
int password = TSUtility.readstock(6);
System.out.print("请输入你的年龄:");//年龄
int age = TSUtility.readstock(2);
System.out.print("请输入你的性别:");//性别
String gender = TSUtility.readKeyBoard(2, false);
System.out.print("请输入你的电话:");//电话
String telNumber = TSUtility.readKeyBoard(11, false);
System.out.print("请输入你的院系:");//院系
String schoolName = TSUtility.readKeyBoard(20, false);
SimpleDateFormat sim = new SimpleDateFormat("yyyy--MM--dd");//使用SimpleDateFormat，同时给定个格式
Date d = new Date();//创建一个Date对象，该Date对象是创建时的事件
String date = sim.format(d);//记录存入的日期
if (isStudent) {//如果是普通用户
//创建普通用户
User commonUser = new User(UID, password, name, age, gender, telNumber, schoolName, date, new UserAccount(ACID, 6, 0));
arr.add(commonUser);//添加到集合中
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\UserList.txt"));
out.writeObject(arr);//把集合写入文件
out.close();//释放资源
System.out.println("注册成功");
return;
}
if (isTeacher) {//如果是管理用户
//创建管理用户
User administrator = new User(UID, password, name, age, gender, telNumber, schoolName, date);
arr.add(administrator);//添加到集合中
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\UserList.txt"));
out.writeObject(arr);//把集合写入文件
out.close();//释放资源
System.out.println("注册成功");
return;
}
}
}else if (isEntering == -1){
System.out.println("你输入的名字错误");
return;
} else {//如果注册的信息未被录入
System.out.println("你输入的UID和姓名未被注册，请联系管理员");//给出提示
return;//结束死循环
}
}
}
//登录功能
public ActiveUser landing() throws IOException, ClassNotFoundException {
//获取已经存在的用户
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\UserList.txt"));
ArrayList<User> arr = (ArrayList<User>) in.readObject();
in.close();//释放登入资源
System.out.print("请输入学号或者教师编号:");
String UID = TSUtility.readKeyBoard(10, false);
System.out.print("请输入密码:");
int password = TSUtility.readstock(6);
boolean isTrue = false;//判断是否与文件中的账户密码匹配
for (User u : arr) {//遍历从文件中取到的账户信息
if (u.getUID().equals(UID)) {//账号正确
if (u.getPassword() == password) {//密码正确
isTrue = true; //旗帜变为true
}
}
}
if (isTrue) {//匹配
StringBuilder A = new StringBuilder();//学号或者教师编号的格式
for (int x = 0; x < 7; x++) {
A = A.append(UID.charAt(x));//拼接得到对应的格式
}
String name = A.toString();//转为String
if (name.equals("student")) {//如果是普通用户
//读入用户列表数据
ObjectInputStream loginIn = new ObjectInputStream(new FileInputStream("Job\\src\\File\\UserList.txt"));
ArrayList<User> arr1 = (ArrayList<User>) loginIn.readObject();//存放用户列表
in.close();//释放资源
int index = 0;对应用户列表中的索引
int credit_rating = 0;//信用系数
String credit = "";//信用等级
for (int x = 0; x < arr1.size(); x++) {
if (arr1.get(x).getUID().equals(UID)) {//找到对应的用户
index = x;//记录对应用户列表中的索引
credit_rating = arr1.get(x).getUserAccount().getCredit_rating();//对应用户列表中当前用户的信用系数
if (credit_rating >= 0 && credit_rating < 3) {//极差系数
credit = "极差";
} else if (credit_rating >= 3 && credit_rating < 6) {//较差系数
credit = "较差";
} else if (credit_rating >= 6 && credit_rating < 9) {//良好系数
credit = "良好";
} else if (credit_rating >= 9 && credit_rating < 12) {//优秀系数
credit = "优秀";
} else if (credit_rating >= 12) {//极优系数
credit = "极优";
} else {//信用比极差还低无发找兼职
credit = "无";
}
break;
}
}
ActiveUser activeUser = new ActiveUser(arr1.get(index), index, credit);
return activeUser;
} else {//如果是管理员
//读入用户列表数据
ObjectInputStream loginIn = new ObjectInputStream(new FileInputStream("Job\\src\\File\\UserList.txt"));
ArrayList<User> arr1 = (ArrayList<User>) loginIn.readObject();//存放用户列表
in.close();//释放资源
int index = 0;//对应数组索引
for (int x = 0; x < arr1.size(); x++) {//找到对应的管理员用户
if (arr1.get(x).getUID().equals(UID)) {
index = x;//记录对应用户列表中的索引
}
}
ActiveUser activeUser = new ActiveUser(arr1.get(index), index);
return activeUser;
}
} else {//不匹配
return null;
}
}
//找回密码
public void find() throws IOException, ClassNotFoundException {
//获取已经存在的用户
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\UserList.txt"));
ArrayList<User> arr = (ArrayList<User>) in.readObject();
in.close();//释放登入资源
//要找回密码的学号或者教师编号
System.out.print("请输入你要找回密码的学号或者教师编号:");
String UID = TSUtility.readKeyBoard(10, false);
boolean isFlag = false;//判断是否找到对应的学号
for (User u : arr) {//集合遍历
if (u.getUID().equals(UID)) {//寻找对应的学号或者教师编号
isFlag = true;
}
}
if (isFlag) {
System.out.print("请输入你当时注册的姓名");
String name = TSUtility.readKeyBoard(4, false);
boolean isName = false;
int password = 0;
for (User u : arr) {//集合遍历
if (u.getName().equals(name)) {//寻找对应的学号或者教师编号
isName = true;
password = u.getPassword();
}
}
if (isName) {
System.out.println("已经为你找到了密码：" + password);
} else {
System.out.println("未找到对应的姓名");
}
} else {
System.out.println("未找到对应的学号或者教师编号");
}
}
//判断输入的值是否已经被录入
public int judgeEntering(String UID, String name, Map<String, String> map) {
Set<String> set = map.keySet();//得到map集合的键
int judge = 0;//判断是否录入的旗帜
for (String s : set) {//增强for循环
if (UID.equals(s)) {//如果UID与录入的信息匹配
if (name.equals(map.get(s))) {//如果输入的name与录入的信息匹配
judge = 1;
}else {
judge=-1;
}
}
}
return judge;//返回旗帜
}
}ModifyCommon:
public class ModifyCommon {//修改普通用户类
//修改年龄、性别、电话、院系、姓名
public void messageModify(ActiveUser activeUser) throws IOException, ClassNotFoundException {
//姓名修改
System.out.print("你的姓名修改为(原数据:" + activeUser.getUser().getName() + "):");
String name = TSUtility.readString(4, activeUser.getUser().getName(), true);
activeUser.getUser().setName(name);//数据修改
//年龄修改
System.out.print("你的年龄修改为(原数据:" + activeUser.getUser().getAge() + "):");
int age = TSUtility.readInt(activeUser.getUser().getAge(),2);
activeUser.getUser().setAge(age);//数据修改
//性别修改
System.out.print("你的性别修改为(原数据:" + activeUser.getUser().getGender() + "):");
String gender = TSUtility.readString(2, activeUser.getUser().getGender(), true);
activeUser.getUser().setGender(gender);//数据修改
//电话修改
System.out.print("你的电话修改为(原数据:" + activeUser.getUser().getTelNumber() + "):");
String telNumber = TSUtility.readString(11, activeUser.getUser().getTelNumber(), true);
activeUser.getUser().setTelNumber(telNumber);//数据修改
//院系修改
System.out.print("你的院系修改为(原数据:" + activeUser.getUser().getSchoolName() + "):");
String schoolName = TSUtility.readString(20, activeUser.getUser().getSchoolName(), true);
activeUser.getUser().setSchoolName(schoolName);//数据修改
saveFile(activeUser);
System.out.println("修改成功");
}
//修改密码
public void passWordModify(ActiveUser activeUser) throws IOException, ClassNotFoundException {
//密码修改
System.out.print("请输入新密码(原密码:" + activeUser.getUser().getPassword() + "):");
int passWord = TSUtility.readInt(activeUser.getUser().getPassword(),6);//得到新密码
activeUser.getUser().setPassword(passWord);//密码修改
saveFile(activeUser);//实时更新用户列表
System.out.println("修改成功");
}
//查询信用等级
public void getCredit(ActiveUser activeUser){
if (activeUser.getCredit().equals("极优")){//如果当前用户信用等级是“极优”按以下显示
System.out.println("当前你的信用等级为:"+activeUser.getCredit());
}else if (activeUser.getCredit().equals("优秀")){//如果当前用户信用等级是”优秀“按以下显示
System.out.print("当前你的信用等级为:"+activeUser.getCredit());
System.out.println(",按时完成"+(12 - activeUser.getUser().getUserAccount().getCredit_rating())+"次后信用等级恢复至极优");
}else if (activeUser.getCredit().equals("良好")){//如果当前用户信用等级是”良好“按以下显示
System.out.print("当前你的信用等级为:"+activeUser.getCredit());
System.out.println(",按时完成"+(9 - activeUser.getUser().getUserAccount().getCredit_rating())+"次后信用等级恢复至优秀");
}else if (activeUser.getCredit().equals("较差")){//如果当前用户信用等级是”较差“按以下显示
System.out.print("当前你的信用等级为:"+activeUser.getCredit());
System.out.println(",按时完成"+(6 - activeUser.getUser().getUserAccount().getCredit_rating())+"次后信用等级恢复至良好");
}else {//如果当前用户信用等级是”极差“按以下显示
System.out.print("当前你的信用等级为:"+activeUser.getCredit());
System.out.println(",按时完成"+(3 - activeUser.getUser().getUserAccount().getCredit_rating())+"次后信用等级恢复至较差");
}
}
//查询余额
public void getBalance(ActiveUser activeUser){
System.out.println("当前你的账户余额为:"+activeUser.getUser().getUserAccount().getBalance());
}
//实时更新
public void saveFile(ActiveUser activeUser) throws IOException, ClassNotFoundException{
//读取用户列表
ObjectInputStream inList = new ObjectInputStream(new FileInputStream("Job\\src\\File\\UserList.txt"));
ArrayList<User> arr = (ArrayList<User>) inList.readObject();//得到的用户列表
inList.close();//释放资源
//把当前用户修改后的用户信息放入列表
arr.set(activeUser.getIndex(),activeUser.getUser());
//把修改后的用户列表存入文件中
ObjectOutputStream outList = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\UserList.txt"));
outList.writeObject(arr);//放入文件
outList.close();//释放资源
}
}Vindicate:
public class Vindicate {//基本信息维护
//兼职等级设置
public void jobLevel() throws IOException, ClassNotFoundException {//兼职等级设置
ArrayList<Job> arr = getJobMessage();//得到兼职列表
System.out.print("请输出你要修改的兼职JTID:");
int jTID = TSUtility.readstock(3);//输入要修改的JTID
boolean isFlag = true;//旗帜
for (int x = 0; x < arr.size(); x++) {//遍历兼职列表集合
if (arr.get(x).getJobType_name().getJjTID() == jTID) {//如果输入的JTID与列表中的吻合
while (isFlag) {//使用死循环判断输入的兼职等级格式是否正确
System.out.println("兼职等级分别为一、二、三、四、五个等级");//提示兼职等级格式
System.out.print("请输入你你要将此兼职的兼职等级设置为");
System.out.print("(原等级为" + arr.get(x).getJob_level() + ",回车表示不修改):");//提示原等级以及回车表示不修改
String level = TSUtility.readString(1, arr.get(x).getJob_level(), true);//输入要修改的等级
//判断输入的是否是这五个等级如果不是就重新输入
if (level.equals("一") || level.equals("二") || level.equals("三") || level.equals("四") || level.equals("五")) {
arr.get(x).setJob_level(level);//修改兼职列表对应的兼职等级
isFlag = false;//修改成功就修改旗帜为false
} else {//如果格式不对就从新执行循环
System.out.println("你修改的格兼职等级格式不对，请重新修改");//提示格式不对
}
}
}
}
if (isFlag){
System.out.println("你输入的JTID不存在");//如果输入的JTID不存在兼职列表中就提示不存在
}else {
saveMessage(arr);//使用saveMessage保存数据
System.out.println("修改成功");//提示修改成功
}
}
//用户信用调整
public void userCredit() throws IOException, ClassNotFoundException {
//反序列化
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\UserList.txt"));
ArrayList<User> arr = (ArrayList<User>) in.readObject();//得到对应的用户数据
in.close();//释放资源
System.out.println("请输入你要修改学生的学号:");//提示输入学号
String UID = TSUtility.readKeyBoard(10, false);//得到学号
boolean isFlag = true;//判断是否找到对应的人做旗帜
for (User u : arr) {//遍历用户
if (u.getUID().equals(UID)) {//如果得到的UID与列表中的UID匹配
if (u.getUserAccount().getCredit_rating() >= 3) {//如果不是极差则执行下面
while (isFlag) {//死循环
System.out.print("请输入你要此用户的信用调整为(极差、较差、良好、优秀、极优):");//输入要修改的值
String credit = TSUtility.readKeyBoard(2, false);
if (credit.equals("极差")) {//得到的值为极差
u.getUserAccount().setCredit_rating(0);//修改当前用户的credit_rating为0
isFlag = false;//旗帜修改为false
} else if (credit.equals("较差")) {//得到的值为较差
u.getUserAccount().setCredit_rating(3);//修改当前用户的credit_rating为3
isFlag = false;//旗帜修改为false
} else if (credit.equals("良好")) {//得到的值为良好
u.getUserAccount().setCredit_rating(6);//修改当前用户的credit_rating为6
isFlag = false;//旗帜修改为false
} else if (credit.equals("优秀")) {//得到的值为优秀
u.getUserAccount().setCredit_rating(9);//修改当前用户的credit_rating为9
isFlag = false;//旗帜修改为false
} else if (credit.equals("极优")) {//得到的值为极优
u.getUserAccount().setCredit_rating(12);//修改当前用户的credit_rating为12
isFlag = false;//旗帜修改为false
} else {//得到的值不是上面这五种情况则执行下面
System.out.println("格式错误，请重新输入");
}
}
} else {//如果输入的用户信用为极差
System.out.println("该用户信用等级为极差无法修改");
}
}
}
if (isFlag) {//如果旗帜为true执行下面
System.out.println("未找到该用户");
} else {//不是存入数据
//序列化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\UserList.txt"));
out.writeObject(arr);//存入数据
out.close();//释放资源
System.out.println("修改成功");//提示修改成功
}
}
//调整逾期费用扣除
public void modifyDeduct() throws IOException, ClassNotFoundException {
ArrayList<Job> arr = getJobMessage();//使用getJobMessage得到对应的兼职列表集合
System.out.println("请输入你要修改的兼职JTID:");
int jTID = TSUtility.readstock(3);//输入要修改的兼职JTID
boolean isFlag = true;//做旗帜判断输出说明
for (int x = 0; x < arr.size(); x++) {//遍历兼职列表集合
if (arr.get(x).getJobType_name().getJjTID() == jTID){//如果输入的JTID与兼职列表中的某一JTID匹配
//提示输入
System.out.println("请输入你将逾期费用修改为（原数据"+arr.get(x).getJobType_name().getDeduct_salary()+",回车表示不修改):");
int deduct = TSUtility.readInt(arr.get(x).getJobType_name().getJjTID(),3);//得到要修改为的逾期费用数据
arr.get(x).getJobType_name().setDeduct_salary(deduct);//修改对应的逾期费用
isFlag = false;//旗帜改为false
}
}
if (isFlag){//如果旗帜为true就显示对应的数据
System.out.println("未找到对应的兼职信息");
}else {//如果是false
saveMessage(arr);//保存数据
System.out.println("修改成功");//提示修改成功
}
}
//获得兼职信息列表
public ArrayList<Job> getJobMessage() throws IOException, ClassNotFoundException {
//反序列化对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Job\\src\\File\\JobMessage.txt"));
ArrayList<Job> arr = (ArrayList<Job>) in.readObject();//得到集合
in.close();//释放资源
return arr;//返回兼职列表集合
}
//保存修改后的兼职列表数据
public void saveMessage(ArrayList<Job> arr) throws IOException {
//序列化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Job\\src\\File\\JobMessage.txt"));
out.writeObject(arr);//把输入的数据保存
out.close();//释放资源
}
}视图就自己去实现
扫一扫
469
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
