本周总结：
本周是考核周，在这周进行了后端第二阶段考核，考核主要内容是自由发挥写一个基于控制台的管理系统，方向自由选择，我写的是药房管理系统，包含增删改查，难点是选择恰当的IO流进行数据的存储，数据的读写功能；各个系统之间的跳转问题，和锁定唯一的管理员账号。在这次考核中我写的代码很烂，基本是根据原来的学生管理系统进行了适当修改，并且IO流没有学好，记录数据异常，不能有效写出数据和记录读取数据，最重要的东西不会，所以说系统写的非常烂。
烂代码展示：
系统由五部分构成（五个类）。
主页面部分：
我用IO的思路：创建两个集合分别将用户信息和药品信息存入集合，再用序列化流将集合中的对象写入文件中，再用反序列化流将对象信息读在控制台。
主页面部分按先后顺序，先是创建用户的集合用来存储用户信息，创建文件，再写序列化流和反序列化流，用switch语句来对系统的功能选项进行连接，功能选项的连接用方法来实现，主要方法是login（登录）,register（注册）,forgetPassword（忘记密码）,administrators（管理员入口）四个主方法。
login方法中用contains方法来比较要登录的用户名是否存在，getCode方法用来获取验证码，如果用户名存在且密码和验证码正确，就提示登录成功，通过创建药房管理系统的对象调用药房管理系统的方法，跳转到药房管理系统，如果超过三次密码输入错误就会锁定账号。
register方法要求：
用户名唯一，用户名长度在3-15个字符之间，只能是数字加字母组合
密码要求输入两次密码必须一摸一样
身份证号码必须满足18位，第一位不能是0，最后一位可以是数字或者大写X或者小写x
手机号码必须满足11位，不能以0开头，必须是数字
最后创建对象，添加集合。
forgetPassword方法，首先判断用户名是否存在，再校验身份证和手机号信息，若以上信息都正确就可以修改密码
administrators方法跟login方法基本相似。
重要方法：getCode
用来获取五位验证码，包括四个大写或小写字母加一个数字，数字的位置任意
方法实现：
创建一个字符集合，先添加大写和小写的26个字母
用StringBuilder方法随机获取四个字母，并添加到方法中，再随机获取一个数字，将字符串变成字符数组，通过获取随机索引，打乱字符数组中各个字符的顺序，最后返回一个字符串。
import java.io.*;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
//drugstore药房
public class drugstore {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//创建集合
ArrayList<User> list = new ArrayList<>();
//创建文件
File file = new File("D:\\后端第二次考核\\user.txt");
//序列化流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\后端第二次考核\\user.txt",true));
oos.writeObject(list);
oos.flush();
oos.close();
//反序列化流
if(!file.exists()){
file.createNewFile();
}
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\后端第二次考核\\user.txt"));
ArrayList<User> user = (ArrayList<User>) ois.readObject();
ois.close();
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("欢迎来到药房");
System.out.println("请先验证身份信息");
System.out.println("请选择操作：1.登录 2.注册 3.忘记密码 4.管理员入口 5.退出");
String choose = sc.next();
switch (choose){
case "1":
login(user);
break;
case "2":
register(list);
System.out.println(list.size());
oos.writeObject(list);
oos.flush();
oos.close();
break;
case "3":
forgetPassword(list);
break;
case "4":
administrators(list);
case "5":
{
System.out.println("谢谢使用，再见");
System.exit(0);
}
default:
System.out.println("没有这个选项");
}
}
}
private static void login(ArrayList<User> list) throws IOException, ClassNotFoundException {
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("请输入用户名");
String username = sc.next();
//判断用户名是否存在
boolean flag = contains(list, username);
if(!flag){
System.out.println("用户名" + username + "未注册，请先注册再登录");
return;
}
System.out.println("请输入密码");
String password = sc.next();
while (true) {
String rightCode = getCode();
System.out.println("当前正确的验证码为：" + rightCode);
System.out.println("请输入验证码");
String code = sc.next();
if(code.equalsIgnoreCase(rightCode)){
System.out.println("验证码正确");
break;
}else {
System.out.println("验证码错误");
continue;
}
}
//验证用户名和密码是否正确
//集合中是否包含用户名和密码
//定义一个方法验证用户名和密码是否正确
//封装思想的应用：
//我们可以把一些零散的数据，封装成一个对象
//以后传递参数的时候，只要传递一个整体就可以了，不需要管这些零散的数据。
User userInfo = new User(username,password,null,null);
boolean result = checkUserInfo(list,userInfo);
if(result){
System.out.println("登录成功，可以开始使用药店管理系统了");
//创建对象调用方法，启动药房管理系统
Pharmacy_management_system pms = new Pharmacy_management_system();
pms.startPharmacy_management_system();
break;
}else {
System.out.println("登陆失败，用户名或密码错误");
if(i == 2){
System.out.println("当前账号" + username + "被锁定，请联系管理员：13599876553");
//当前账号锁定之后，直接结束方法即可
return;
}else {
System.out.println("当前用户名或密码错误，还剩下" + (2 - i) + "次机会");
}
}
}
}
private static void register(ArrayList<User> list) {
//1.键盘录入用户名
//先验证格式是否正确，再验证是否唯一。
//用户名要求：用户名唯一，用户名长度必须在3~15位之间，只能是字母加数字的组合，但是不能是纯数字。
Scanner sc = new Scanner(System.in);
String username;
String password;
String personID;
String phoneNumber;
while (true) {
System.out.println("请输入用户名");
username = sc.next();
boolean flag1 = checkUsername(username);
if(!flag1){
System.out.println("用户名格式不满足条件，需要重新输入");
continue;
}
//校验用户名唯一
//拿着username到集合中判断是否已经存在
boolean flag2 = contains(list,username);
if (flag2){
//用户名已存在，那么当前用户名无法注册，需要重新输入
System.out.println("用户名" + username + "已存在，请重新输入");
}else {
//不存在，表示当前用户名可用，可以继续录入下面的其他数据
System.out.println("用户名" + username + "可用");
break;
}
}
//2.键盘录入密码
//密码键盘输入两次，两次一样才可以进行注册
while (true) {
System.out.println("请输入要注册的密码");
password = sc.next();
System.out.println("请再次输入要注册的密码");
String againPassword = sc.next();
if(!againPassword.equals(password)){
System.out.println("两次密码输入不一致，请重新输入");
continue;
}else {
System.out.println("两次密码一致，继续录入其他数据");
break;
}
}
//3.键盘录入身份证号码
while (true) {
System.out.println("请输入身份证号码");
personID = sc.next();
boolean flag = checkpersonID(personID);
if(flag){
System.out.println("身份证号码满足要求");
break;
}else {
System.out.println("身份证号码格式有误，请重新输入");
continue;
}
}
//4.键盘录入手机号码
while (true) {
System.out.println("请输入手机号码");
phoneNumber = sc.next();
boolean flag = checkPhoneNumber(phoneNumber);
if(flag){
System.out.println("手机号码格式正确");
break;
}else {
System.out.println("手机号码格式有误，请重新输入");
continue;
}
}
//用户名，密码，身份证号码，手机号码放到用户对象中
User u = new User(username,password,personID,phoneNumber);
//把用户对象添加到集合中
list.add(u);
System.out.println("注册成功");
//遍历集合
printList(list);
}
private static void forgetPassword(ArrayList<User> list) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String username = sc.next();
boolean flag = contains(list, username);
if(!flag){
System.out.println("当前用户" + username + "未注册，请先注册");
return;
}
//键盘录入身份证号码和手机号码
System.out.println("请输入身份证号码");
String personID = sc.next();
System.out.println("请输入手机号码");
String phoneNumber = sc.next();
//比较用户对象中的手机号码和身份证号码是否相同
//需要把用户对象先获取出来
int index = findIndex(list,username);
User user = list.get(index);
if(!(user.getPersonID().equals(personID) && user.getPhoneNumber().equals(phoneNumber))){
System.out.println("身份证号码或手机号码输入有误，不能修改密码");
return;
}
//当代码执行到这里，表示所有的数据全部验证成功，直接修改即可
String password;
while (true) {
System.out.println("请输入新的密码");
password = sc.next();
System.out.println("请再次输入新的密码");
String againPassword = sc.next();
if(password.equals(againPassword)){
System.out.println("两次密码输入一致");
break;
}else {
System.out.println("两次密码输入不一致，请重新输入");
continue;
}
}
//直接修改即可
user.setPassword(password);
System.out.println("密码修改成功");
}
private static void administrators(ArrayList<User> list) throws IOException, ClassNotFoundException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String username = sc.next();
//判断用户名是否存在
boolean flag = contains(list, username);
if(!flag){
System.out.println("用户名" + username + "未注册，请先注册再登录");
return;
}
System.out.println("请输入密码");
String password = sc.next();
while (true) {
String rightCode = getCode();
System.out.println("当前正确的验证码为：" + rightCode);
System.out.println("请输入验证码");
String code = sc.next();
if(code.equalsIgnoreCase(rightCode)){
System.out.println("验证码正确");
break;
}else {
System.out.println("验证码错误");
continue;
}
}
//验证用户名和密码是否正确
//集合中是否包含用户名和密码
//定义一个方法验证用户名和密码是否正确
//封装思想的应用：
//我们可以把一些零散的数据，封装成一个对象
//以后传递参数的时候，只要传递一个整体就可以了，不需要管这些零散的数据。
User userInfo = new User(username,password,null,null);
boolean result = checkUserInfo(list,userInfo);
if(result){
System.out.println("登录成功，可以开始使用用户管理系统了");
//创建对象调用方法，启动用户管理系统
User_management_system pms = new User_management_system();
pms.startUser_management_system();
}else {
System.out.println("登陆失败，用户名或密码错误");
}
}
private static int findIndex(ArrayList<User> list, String username) {
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
if(user.getUsername().equals(username)){
return i;
}
}
return -1;
}
private static boolean checkUserInfo(ArrayList<User> list, User userInfo) {
//遍历集合，判断用户是否存在，如果存在登录成功，如果不存在登录失败
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
if(user.getUsername().equals(userInfo.getUsername()) && user.getPassword().equals(userInfo.getPassword())){
return true;
}
}
return false;
}
private static void printList(ArrayList<User> list) {
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
System.out.println(user.getUsername() + ", " + user.getPassword() + ", " + user.getPersonID() + ", " + user.getPhoneNumber());
}
}
private static boolean checkPhoneNumber(String phoneNumber) {
//长度为11位
if(phoneNumber.length() != 11){
return false;
}
//不能以0为开头
if(phoneNumber.startsWith("0")){
return false;
}
//必须都是数字
for (int i = 0; i < phoneNumber.length(); i++) {
char c = phoneNumber.charAt(i);
if(!(c >= '0' && c <= '9')){
return false;
}
}
//当循环结束之后，表示每一个字符都在0-9之间
return true;
}
private static boolean checkpersonID(String personID) {
//长度为18位
if(personID.length() != 18){
return false;
}
//不能以0为开头
if(personID.startsWith("0")){
//如果以0开头，那么返回false
return false;
}
//前17位，必须都是数字
for (int i = 0; i < personID.length() - 1; i++) {
char c = personID.charAt(i);
//如果有一个字符不在0-9之间，那么直接返回false
if (!(c >= '0' && c <= '9')){
return false;
}
}
//最后一位可以是数字，也可以是大写X或小写x
char endChar = personID.charAt(personID.length() - 1);
if((endChar >= '0' && endChar <= '9') || (endChar == 'X') || (endChar == 'x')){
return true;
}else {
return false;
}
}
private static boolean contains(ArrayList<User> list, String username) {
//循环遍历集合得到每一个用户对象
//拿着用户对象中的用户名进行比较
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
String rightUsername = user.getUsername();
if(rightUsername.equals(username)){
return true;
}
}
//循环结束后，表示集合里面所有的用户都比较完毕了，都没有一样的，返回false。
return false;
}
private static boolean checkUsername(String username) {
//用户名长度必须在3~15位之间
int len = username.length();
if(len < 3 || len > 15){
return false;
}
//当代码执行到这里，表示用户名的长度是符合要求的。
//继续校验：只能是字母加数字的组合
//循环得到username里面的每一个字符，如果有一个字符不是字母或者数字，就返回false。
for (int i = 0; i < username.length(); i++) {
char c = username.charAt(i);
if(!((c >= 'a' && c <= 'z')||(c >= 'A' && c <= 'Z')||(c >= '0' && c <= '9'))){
return false;
}
}
//当代码执行到这里，用户名满足两个要求：1.长度满足 2.内容也满足（字母＋数字）
//但是不能是纯数字
//统计在用户名中，有多少个字母
int count = 0;
for (int i = 0; i < username.length(); i++) {
char c = username.charAt(i);
if((c >= 'a' && c <= 'z')||(c >= 'A' && c <= 'Z')){
count++;
break;
}
}
return count > 0;
}
//生成一个验证码
private static String getCode(){
//1.创建一个集合添加所有的大写和小写字母
ArrayList<Character> list = new ArrayList<>();
for (int i = 0; i < 26; i++) {
list.add((char)('a' + i));
list.add((char)('A' + i));
}
StringBuilder sb = new StringBuilder();
//2.随机抽取四个字符
Random r = new Random();
for (int i = 0; i < 4; i++) {
//获取随机索引
int index = r.nextInt(list.size());
//利用随机索引获取字符
char c = list.get(index);
//把随机字符添加到sb当中
sb.append(c);
}
//3.把一个随机数字添加到末尾
int number = r.nextInt(10);
sb.append(number);
//4.如果我们要修改字符串中的内容
//先把字符串变成字符数组，在数组中修改，然后再创建一个新的字符串
char[] arr = sb.toString().toCharArray();
//拿着最后一个索引，跟随机索引进行交换
int randomIndex = r.nextInt(arr.length);
//最大索引指向的元素跟随机索引指向的元素交换
char temp = arr[randomIndex];
arr[randomIndex] = arr[arr.length - 1];
arr[arr.length - 1] = temp;
return new String(arr);
}
}
药房管理系统部分：
代码跟主页面较相似，包含增删改查四个部分，添加元素不用过多阐述，删除和修改通过药品ID进行校验是否存在，若存在可以执行，如果不存在就提示，查找部分没有进行细分，属于是遍历集合。
import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
public class Pharmacy_management_system {
public static void startPharmacy_management_system() throws IOException, ClassNotFoundException {
//File file = new File("Pharmacy_management_system\\src\\data.txt");
//FileInputStream fis = new FileInputStream("Pharmacy_management_system\\src\\data.txt");
//FileOutputStream fos = new FileOutputStream("Pharmacy_management_system\\src\\data.txt",true);
//BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Pharmacy_management_system\\src\\data.txt"));
//BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Pharmacy_management_system\\src\\data.txt"));
ArrayList<Drug> list = new ArrayList<>();
//创建文件
File file = new File("D:\\后端第二次考核\\data.txt");
//序列化流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\后端第二次考核\\data.txt"));
oos.writeObject(list);
oos.flush();
oos.close();
//反序列化流
if(!file.exists()){
file.createNewFile();
}
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\后端第二次考核\\data.txt"));
ArrayList<Drug> drug = (ArrayList<Drug>) ois.readObject();
ois.close();
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("请输入您的选择：");
Scanner sc = new Scanner(System.in);
String choose = sc.next();
switch (choose){
case "1":
addDrug(list);
break;
case "2":
deleteDrug(list);
break;
case "3":
updateDrug(list);
break;
case "4":
queryDrug(list);
break;
case "5": {
System.out.println("5.退出");
System.exit(0);
}
default:
System.out.println("没有这个选项");
}
}
}
private static void queryDrug(ArrayList<Drug> list) {
if(list.size() == 0){
System.out.println("当前无药品信息，请添加后再查询");
//结束方法
return;
}
System.out.println("药品ID\t药名\t药效\t生产厂家\t安全等级\t数量\t适用人群");
//当代码执行到这里，表示集合中有数据
for (int i = 0; i < list.size(); i++) {
Drug drug = list.get(i);
System.out.println(drug.getDrugID() + "\t" + drug.getDrugName() + "\t\t" + drug.getPesticide_Effect() + "\t\t" +
drug.getManufacturer() + "\t" + drug.getSafety_Level() + "\t" + drug.getQuantity() + "\t" + drug.getSuit());
}
}
private static void updateDrug(ArrayList<Drug> list) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入要修改的药品ID");
String drugID = sc.next();
int index = getIndex(list, drugID);
if(index == -1){
System.out.println("要修改的药品ID" + drugID + "不存在，请重新输入");
return;
}
//获取要修改的药品对象
Drug drug = list.get(index);
//输入其他信息并修改
System.out.println("请输入药名");
String newDrugName = sc.next();
drug.setDrugName(newDrugName);
System.out.println("请输入药效");
String newPesticide_Effect = sc.next();
drug.setPesticide_Effect(newPesticide_Effect);
System.out.println("请输入药品生产厂家");
String newManufacturer = sc.next();
drug.setManufacturer(newManufacturer);
System.out.println("请输入药品安全等级");
String newSafety_Level = sc.next();
drug.setSafety_Level(newSafety_Level);
System.out.println("请输入药品数量");
String newQuantity = sc.next();
drug.setQuantity(newQuantity);
System.out.println("请输入药品适用人群");
String newSuit = sc.next();
drug.setSuit(newSuit);
System.out.println("药品信息修改成功");
}
private static void deleteDrug(ArrayList<Drug> list) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入要删除的id");
String drugID = sc.next();
//查询ID在集合中的索引
int index = getIndex(list, drugID);
if(index >= 0){
list.remove(index);
System.out.println("drugID为" + drugID + "药品删除成功");
}else {
System.out.println("drugID不存在，删除失败");
}
}
private static void addDrug(ArrayList<Drug> list) {
Drug drug = new Drug();
Scanner sc = new Scanner(System.in);
String drugID = null;
while (true) {
System.out.println("请输入药品ID");
drugID = sc.next();
boolean flag = contains(list, drugID);
if(flag){
System.out.println("ID已经存在，请重新录入");
}else {
drug.setDrugID(drugID);
break;
}
}
System.out.println("请输入药名");
String drugName = sc.next();
drug.setDrugName(drugName);
System.out.println("请输入药效");
String pesticide_Effect = sc.next();
drug.setPesticide_Effect(pesticide_Effect);
System.out.println("请输入药品生产厂家");
String manufacturer = sc.next();
drug.setManufacturer(manufacturer);
System.out.println("请输入药品安全等级");
String safety_Level = sc.next();
drug.setSafety_Level(safety_Level);
System.out.println("请输入药品数量");
String quantity = sc.next();
drug.setQuantity(quantity);
System.out.println("请输入药品适用人群");
String suit = sc.next();
drug.setSuit(suit);
//将药品对象添加到集合中
list.add(drug);
System.out.println("药品信息添加成功");
}
//判断ID在集合中是否存在
public static boolean contains(ArrayList<Drug> list, String drugID){
//循环遍历集合得到里面的每一个药品对象
for (int i = 0; i < list.size(); i++) {
//拿到药品对象之后，获取drugID并进行判断
Drug drug = list.get(i);
String id = drug.getDrugID();
if(drugID.equals(id)){
//存在。true
return true;
}
}
//不存在，false.
return false;
}
//通过drugID获取索引的方法
public static int getIndex(ArrayList<Drug> list, String drugID){
//遍历集合
for (int i = 0; i < list.size(); i++) {
//得到每一个药品对象
Drug drug = list.get(i);
//得到每一个药品对象的药品ID
String id = drug.getDrugID();
//拿着集合中的药品ID跟要删除的药品ID作比较
if(id.equals(drugID)){
//如果一样，返回索引
return i;
}
}
//循环结束后还没有找到，就表示不存在，返回-1
return -1;
}
}
药品的javaBean类：
import java.io.Serializable;
public class Drug implements Serializable {
// private static final long serialVersionUID = 666L;
//药品ID
private String drugID;
//药名
private String drugName;
//药效
private String pesticide_Effect;
//生产厂家
private String manufacturer;
//安全等级
private String safety_Level;
//数量
private String quantity;
//适用人群
private String suit;
public Drug() {
}
public Drug(String drugID, String drugName, String pesticide_Effect, String manufacturer, String safety_Level, String quantity, String suit) {
this.drugID = drugID;
this.drugName = drugName;
this.pesticide_Effect = pesticide_Effect;
this.manufacturer = manufacturer;
this.safety_Level = safety_Level;
this.quantity = quantity;
this.suit = suit;
}
public String getDrugID() {
return drugID;
}
public void setDrugID(String drugID) {
this.drugID = drugID;
}
public String getDrugName() {
return drugName;
}
public void setDrugName(String drugName) {
this.drugName = drugName;
}
public String getPesticide_Effect() {
return pesticide_Effect;
}
public void setPesticide_Effect(String pesticide_Effect) {
this.pesticide_Effect = pesticide_Effect;
}
public String getManufacturer() {
return manufacturer;
}
public void setManufacturer(String manufacturer) {
this.manufacturer = manufacturer;
}
public String getSafety_Level() {
return safety_Level;
}
public void setSafety_Level(String safety_Level) {
this.safety_Level = safety_Level;
}
public String getQuantity() {
return quantity;
}
public void setQuantity(String quantity) {
this.quantity = quantity;
}
public String getSuit() {
return suit;
}
public void setSuit(String suit) {
this.suit = suit;
}
public String toString() {
return "drug{drugID = " + drugID + ", drugName = " + drugName + ", pesticide_Effect = " + pesticide_Effect + ", manufacturer = " + manufacturer + ", safety_Level = " + safety_Level + ", quantity = " + quantity + ", suit = " + suit + "}";
}
}
用户管理系统：
代码跟主页面较相似，写此系统的目的是方便管理员单独管理用户数据，包含增删改查四个方法
import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
public class User_management_system {
public static void startUser_management_system() throws IOException, ClassNotFoundException {
//File file = new File("Pharmacy_management_system\\src\\data.txt");
//FileInputStream fis = new FileInputStream("Pharmacy_management_system\\src\\data.txt");
//FileOutputStream fos = new FileOutputStream("Pharmacy_management_system\\src\\data.txt",true);
//BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Pharmacy_management_system\\src\\data.txt"));
//BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Pharmacy_management_system\\src\\data.txt"));
ArrayList<User> list = new ArrayList<>();
//创建文件
File file = new File("D:\\后端第二次考核\\user.txt");
//序列化流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\后端第二次考核\\user.txt"));
oos.writeObject(list);
oos.flush();
oos.close();
//反序列化流
if(!file.exists()){
file.createNewFile();
}
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\后端第二次考核\\user.txt"));
ArrayList<User> user = (ArrayList<User>) ois.readObject();
ois.close();
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("请输入您的选择：");
Scanner sc = new Scanner(System.in);
String choose = sc.next();
switch (choose){
case "1":
addUser(list);
break;
case "2":
deleteUser(list);
break;
case "3":
updateUser(list);
break;
case "4":
queryUser(list);
break;
case "5": {
System.out.println("5.退出");
System.exit(0);
}
default:
System.out.println("没有这个选项");
}
}
}
private static void queryUser(ArrayList<User> list) {
if(list.size() == 0){
System.out.println("当前无用户信息，请添加后再查询");
//结束方法
return;
}
System.out.println("用户名\t密码\t身份证号码\t手机号码");
//当代码执行到这里，表示集合中有数据
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
System.out.println(user.getUsername() +"\t"+ user.getPassword() +"\t"+ user.getPersonID() +"\t"+ user.getPhoneNumber());
}
}
private static void updateUser(ArrayList<User> list) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入要修改的用户名");
String username = sc.next();
int index = getIndex(list, username);
if(index == -1){
System.out.println("要修改的用户名" + username + "不存在，请重新输入");
return;
}
//获取要修改的用户对象
User user = list.get(index);
//输入其他信息并修改
System.out.println("请输入用户名");
String newUserName = sc.next();
user.setUsername(newUserName);
System.out.println("请输入密码");
String newPassword = sc.next();
user.setUsername(newPassword);
System.out.println("请输入用户身份证号码");
String newPersonID = sc.next();
user.setUsername(newPersonID);
System.out.println("请输入用户手机号码");
String newPhoneNumber = sc.next();
user.setUsername(newPhoneNumber);
System.out.println("用户信息修改成功");
}
private static void deleteUser(ArrayList<User> list) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入要删除用户的用户名");
String username = sc.next();
//查询用户名在集合中的索引
int index = getIndex(list, username);
if(index >= 0){
list.remove(index);
System.out.println("用户名为" + username + "的用户删除成功");
}else {
System.out.println("用户名不存在，删除失败");
}
}
private static void addUser(ArrayList<User> list) {
User user = new User();
Scanner sc = new Scanner(System.in);
String username = null;
while (true) {
System.out.println("请输入用户名");
username = sc.next();
boolean flag = contains(list, username);
if(flag){
System.out.println("用户名已经存在，请重新录入");
}else {
user.setUsername(username);
break;
}
}
System.out.println("请输入密码");
String password = sc.next();
user.setPassword(password);
System.out.println("请输入用户身份证号码");
String personID = sc.next();
user.setPersonID(personID);
System.out.println("请输入用户手机号码");
String PhoneNumber = sc.next();
user.setPhoneNumber(PhoneNumber);
//将用户对象添加到集合中
list.add(user);
System.out.println("用户信息添加成功");
}
//判断用户在集合中是否存在
public static boolean contains(ArrayList<User> list, String username){
//循环遍历集合得到里面的每一个用户对象
for (int i = 0; i < list.size(); i++) {
//拿到用户对象之后，获取用户名并进行判断
User user = list.get(i);
String nowUserName = user.getUsername();
if(username.equals(nowUserName)){
//存在。true
return true;
}
}
//不存在，false.
return false;
}
//通过用户名获取索引的方法
public static int getIndex(ArrayList<User> list, String username){
//遍历集合
for (int i = 0; i < list.size(); i++) {
//得到每一个用户对象
User user = list.get(i);
//得到每一个用户对象的用户名
String nowUserName = user.getUsername();
//拿着集合中的用户名跟要删除的用户名作比较
if(nowUserName.equals(username)){
//如果一样，返回索引
return i;
}
}
//循环结束后还没有找到，就表示不存在，返回-1
return -1;
}
}
用户的javaBean类：
import java.io.Serializable;
public class User implements Serializable {
// private static final long serialVersionUID = 666L;
private String username;
private String password;
private String personID;
private String phoneNumber;
public User() {
}
public User(String username, String password, String personID, String PhoneNumber) {
this.username = username;
this.password = password;
this.personID = personID;
this.phoneNumber = PhoneNumber;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getPersonID() {
return personID;
}
public void setPersonID(String personID) {
this.personID = personID;
}
public String getPhoneNumber() {
return phoneNumber;
}
public void setPhoneNumber(String PhoneNumber) {
this.phoneNumber = PhoneNumber;
}
public String toString() {
return "User{username = " + username + ", password = " + password + ", personID = " + personID + ", PhoneNumber = " + phoneNumber + "}";
}
}
系统总结：
代码太乱，主页面代码过多。
考核问题复习：
break,continue,return的区别：
return ：直接跳出当前的方法,返回方法的调用处,继续执行
break：在循环体内结束整个循环过程
continue ：结束本次的循环，直接进行下一次的循环
相对continue和break而言，return关键字并不是专门用于跳出循环的，return直接结束整个方法，不管这个return处于多少层循环之内。
break和continue都是用来跳出循环，只不过break用来跳出整层循环，continue用来跳出当前循环。
break用于完全结束一个循环，跳出循环体执行循环后面的语句
break适用范围：只能用于switch或者是循环语句中。
break作用：
1、 break用于循环语句中的作用是结束当前所在的循环语句。
2、 break用于switch语句的作用是结束一个switch语句。
比较运算符==跟equals()方法的区别。
“==”和equals()方法最大的区别是：
“==”是运算符，如果比较的是基本数据类型，则是比较存储的值；如果比较的是引用数据类型，则是比较所指向对象的地址值。
equals()是Object的方法，比较的是所指向对象的地址值，但一般情况下，重写之后比较的是对象内容。
equals()不能用来比较基本数据类型，如果没有对equals方法进行重写，则相当于“==”，比较的是引用类型的变量所指向的对象的地址值。
集合的分类及特点。
集合分为单列集合(Collection)和双列集合(Map)
单列结合又能分成List系列集合和Set系列集合
List系列集合中常用的是ArrayList和LinkedList
List系列集合特点：添加的元素是有序（存和取的元素顺序一致）、可重复、有索引。
Set系列集合中常用的是HashSet（无序）,HashSet的子类LinkedHashSet（有序）和TreeSet（可排序）
Set系列集合特点：添加的元素是无序，不重复，无索引。
单列集合的遍历方式：
迭代器遍历
增强for遍历（底层就是迭代器，为了简化书写和美观而存在）
lambda表达式遍历
List系列集合的遍历方式：
List系列集合是Collection的子类，所以继承了上述的三种遍历方式
列表迭代器遍历
普通for循环（因为List集合中存在索引）
IO流的分类。
四个抽象类：InputStream、OutputStream、Reader、Writer。
常用流（16种）：
操作本地文件的流：文件专属
FileInputStream、FileOutputStream、FileReader、FileWriter。
转换流：将字节流装换为字符流
InputStreamReader、OutputStreamWriter。
缓冲流：
BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter。
二进制流：
DataInputStream、DataOutputStream。
序列化流和反序列化流：
ObjectInputStream、ObjectOutputStream。
打印流：
PrintWriter、PrintStream。
字节流和字符流的区别。
字节流和字符流的用法几乎完全一样
区别在于字节流和字符流所操作的数据单元不同
字节流操作的单元是数据单元是8位的字节
字符流操作的是数据单元为16位的字符。
flush()方法和close()方法。
异常的三种处理方式。
JVM自动处理
try...catch...finally
抛出
封装的概念。
封装就是把属于同一类事物的共性（包括属性与方法）归到一个类中，以方便使用。
静态方法的概念。
方法可以分为三种：
构造方法
静态方法（类方法）
非静态方法（实例方法/成员方法/普通方法）
静态方法和非静态方法的区别：调用对象和引用变量不同。
静态方法也叫类方法，是属于类的，不属于对象。在实例化对象之前就可以通过类名.方法名调用静态方法。
类变量：用static修饰的变量。
在静态方法中，不能使用this和super关键字。
6009
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
