Java-简易的学生管理系统升级版

已于 2023-03-25 14:49:32 修改
阅读量193 收藏 2
点赞数 2
分类专栏： Java学习日记 文章标签： java 开发语言 jvm
于 2023-03-25 14:49:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ZEALERHE/article/details/129766678
版权

基于之前的简易学生管理系统做的一个升级版，主要增加了用户登陆的操作

需求如下

需求：

为学生管理系统书写一个登陆、注册、忘记密码的功能。
只有用户登录成功之后，才能进入到学生管理系统中进行增删改查操作。

登录界面：

System.out.println("欢迎来到学生管理系统");
System.out.println("请选择操作1登录 2注册 3忘记密码");

 用户类：

​ 属性：用户名、密码、身份证号码、手机号码

注册功能： 

 1，用户名需要满足以下要求：
​ 验证要求：
​ 用户名唯一
​ 用户名长度必须在3~15位之间
​ 只能是字母加数字的组合，但是不能是纯数字
​ 2，密码键盘输入两次，两次一致才可以进行注册。
​ 3，身份证号码需要验证。
​ 验证要求：
​ 长度为18位
​ 不能以0为开头
​ 前17位，必须都是数字
​ 最为一位可以是数字，也可以是大写X或小写x

4，手机号验证。
​ 验证要求：
​ 长度为11位
​ 不能以0为开头
​ 必须都是数字

登录功能：

 1，键盘录入用户名
​ 2，键盘录入密码
​ 3，键盘录入验证码
验证要求：
​ 用户名如果未注册，直接结束方法，并提示：用户名未注册，请先注册
​ 判断验证码是否正确，如不正确，重新输入
​ 再判断用户名和密码是否正确，有3次机会

忘记密码：

1，键盘录入用户名，判断当前用户名是否存在，如不存在，直接结束方法，并提示：未注册
​ 2，键盘录入身份证号码和手机号码
​ 3，判断当前用户的身份证号码和手机号码是否一致，
​ 如果一致，则提示输入密码，进行修改。
​ 如果不一致，则提示：账号信息不匹配，修改失败。

验证码规则：

长度为5
​ 由4位大写或者小写字母和1位数字组成，同一个字母可重复
​ 数字可以出现在任意位置
比如：
​ aQa1K

代码如下：

Student类:

public class Student {
    private String id;
    private String name;
    private int age;
    private String address;

    //无参构造
    public Student() {
    }
    //带参构造
    public Student(String id, String name, int age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }
    //取id
    public String getId() {
        return id;
    }
    //设置id
    public void setId(String id) {
        this.id = id;
    }
    //取name
    public String getName() {
        return name;
    }
    //设置name
    public void setName(String name) {
        this.name = name;
    }
    //取age
    public int getAge() {
        return age;
    }
    //设置age
    public void setAge(int age) {
        this.age = age;
    }
    //取address
    public String getAddress() {
        return address;
    }
    //设置address
    public void setAddress(String address) {
        this.address = address;
    }
}

 User类

public class User {
    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;
    }
}

StudentManagementSystem类 ：

main方法：

public static void main(String[] args) {
        //创建集合存储学生信息
        ArrayList <Student> list = new ArrayList<>();
        //创建集合存储用户信息
        ArrayList <User> userList = new ArrayList<>();
        Scanner sc = null;

        loop:while (true) {
            //欢迎界面
            System.out.println("欢迎来到学生管理系统");
            System.out.println("请选择操作1登录 2注册 3忘记密码");
            //输入选项
            sc = new Scanner(System.in);
            String choose = sc.next();
            switch (choose){
                //登陆
                case "1":
                    boolean flag = loginUser(userList);
                    if(flag){
                        break loop;
                    }
                    break ;
                //注册
                case "2":
                    registerUser(userList);
                    break;
                //忘记密码
                case "3":
                    forgetPassword(userList);
                    break ;
                default:
                    System.out.println("该选项不存在，请重新选择");
                    break;
            }
        }

        while (true) {
            welcome();
            System.out.println("请输入您的选择：");
            String choose = sc.next();
            switch (choose){
                //添加学生
                case "1":
                    addStudent(list);
                    break;
                //删除学生
                case "2":
                    deleteStudent(list);
                    break;
                //修改学生
                case "3":
                    updateStudent(list);
                    break;
                //查询学生
                case "4":
                    queryStudent(list);
                    break;
                //退出系统
                case "5":
                    System.exit(0);//停止虚拟机运行
                default:
                    System.out.println("输入错误，请重新输入");
                    break;
            }
        }
    }

 welcom方法：

 public static void welcome(){
        //打印欢迎界面
        System.out.println("---------------欢迎来到学生管理系统----------------");
        System.out.println("1：添加学生");
        System.out.println("2：删除学生");
        System.out.println("3：修改学生");
        System.out.println("4：查询学生");
        System.out.println("5：退出");
    }

addStudent方法：

    //添加学生
    public static void addStudent(ArrayList <Student> list){
        Scanner sc = new Scanner(System.in);
        //新建学生对象
        Student student = new Student();
        //添加id
        String id = null;
        //用一个循环添加id，
        while (true) {
            System.out.println("请添加id：");
            id = sc.next();
            //判断id的唯一性
            if(judgeOnly(list,id)){
                //不唯一则提示添加失败，继续循环直至添加成功
                System.out.println("添加失败，已经有该id");
            }
            //唯一则添加完id结束循环
            else{
                student.setId(id);
                break;
            }

        }
        //添加年龄
        System.out.println("请添加年龄：");
        int age = sc.nextInt();
        student.setAge(age);
        //添加姓名
        System.out.println("请添加姓名：");
        String name = sc.next();
        student.setName(name);
        //添加家庭住址
        System.out.println("请添加家庭住址：");
        String address = sc.next();
        student.setAddress(address);
        list.add(student);

    }

 deleteStudent方法:

 //删除学生
    public static void deleteStudent(ArrayList <Student> list){
        Scanner sc =new Scanner(System.in);
        System.out.println("请输入要删除的学生id：");
        String id =sc.next();
        boolean flag = judgeOnly(list, id);
        //判断是否存在相同id，如果存在，就删除
        if(flag){
            //遍历集合，找相同id索引
            for (int i = 0; i < list.size(); i++) {

                Student student = list.get(i);
                if(id.equals(student.getId())){
                    //找到索引，用集合remove方法移除该索引对应元素
                    list.remove(i);
                }
            }
        }
        else{
            System.out.println("不存在该id");
            return;
        }
    }

updateStudent方法：

 //修改学生
    public static void updateStudent(ArrayList <Student> list){
        Scanner sc =new Scanner(System.in);
        System.out.println("请输入要修改的学生id：");
        String id = sc.next();
        //判断id是否存在
        boolean flag = judgeOnly(list, id);
        if(flag){
            //存在则修改id
            System.out.println("该学生存在，请输入要修改的学生信息：");
            //创建一个新的学生对象
            Student newStudent = new Student();
            //将原id传递给新学生对象
            newStudent.setId(id);
            System.out.println("请输入学生的姓名：");
            String name = sc.next();
            newStudent.setName(name);
            System.out.println("请输入学生的年龄：");
            int age = sc.nextInt();
            newStudent.setAge(age);
            System.out.println("请输入学生的家庭住址：");
            String address = sc.next();
            newStudent.setAddress(address);
            //遍历集合，获取id相同的索引
            for (int i = 0; i < list.size(); i++) {

                Student student = list.get(i);
                if(id.equals(student.getId())){
                    list.set(i,newStudent);
                }
            }
        }
        else{
            System.out.println("不存在该id");
            return;
        }

    }

queryStudent方法：

//查询学生
public static void queryStudent(ArrayList <Student> list){
        if(list.size() == 0){
            System.out.println("当前无学生信息，请添加后再查询");
            return;
        }
        else{
            System.out.println("id"+"\t\t"+"姓名"+"\t\t"+"年龄"+"\t\t"+"家庭住址");
            for (int i = 0; i < list.size(); i++) {
               Student student = list.get(i);
                System.out.println(student.getId()+"\t\t"+student.getName()+"\t\t"+student.getAge()+"\t\t"+student.getAddress());

            }
        }

    }

judgeOnly方法：

 //判断唯一性
public static boolean judgeOnly(ArrayList <Student> list,String id){
        //遍历集合
        for (int i = 0; i < list.size(); i++) {

           Student student = list.get(i);
           if(id.equals(student.getId())){
               return true;
           }
        }
        return false;

    }

returnIndex方法：

 //输出id相同的索引
    public static int returnIndex(ArrayList <Student> list,String id){
        for (int i = 0; i < list.size(); i++) {

            Student student = list.get(i);
            if(id.equals(student.getId())){
                return i;
            }
        }
        return -1;
    }

registerUser方法：

//注册用户
    public static void registerUser(ArrayList <User> userList){
        loop:while (true) {
            User user = new User();
            //创建用户名
            loop01:while (true) {
                System.out.println("请输入要创建的用户名：");
                Scanner sc = new Scanner(System.in);
                //输入用户名
                String username = sc.next();
                //判断用户名唯一性
                boolean flag = judgeUserNameOnly(userList, username);
                //创建用户对象

                if(flag){
                    System.out.println("已有该用户，请重新输入!");
                }
                else{
                    //要求2：长度必须在3~15之间
                    if(username.length()<3&&username.length()>15){
                        System.out.println("用户名长度必须为3~15位，您的用户名长度不符合要求，请重新输入!");
                    }
                    else {
                        //要求3：只能是数字加字母，不能是纯数字
                        //1.判断输入的用户名是否在0~9,a~z,A~Z
                        boolean standardFlag = judgeUserNameStandard(username);
                        if(standardFlag){
                            System.out.println("用户名创建成功");
                            user.setUsername(username);
                            break loop01;

                        }
                        else {
                            System.out.println("不符合用户名规范，用户名只能是字母加数字的组合，不能是纯数字或纯字母");
                        }

                    }
                }

            }
            //创建密码
            loop02:while (true) {
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入用户密码：");
                String userPassword01 = sc.next();
                System.out.println("请再次输入用户密码：");
                String userPassword02 =sc.next();
                //验证两次密码是否一致
                if(userPassword02.equals(userPassword01)){
                    System.out.println("密码创建成功！");
                    //将密码添加进user对象
                    user.setPassword(userPassword01);
                    //跳出loop02循环
                    break loop02;
                }
                else{
                    System.out.println("两次密码输入的不一致，请重新创建密码！");
                }
            }
            //录入身份证号
            loop03:while (true) {
                System.out.println("请输入身份证号：");
                Scanner sc = new Scanner(System.in);
                String personId = sc.next();
                //如果身份证号长度等于18位，进行之后操作
                if(personId.length() == 18){
                    //判断身份证号是否符合规范
                    boolean standard = judgePersonIdStandard(personId);
                    if(standard){
                        user.setPersonId(personId);
                        System.out.println("身份证添加成功！");
                        break loop03;
                    }
                    else{
                        System.out.println("您输入的身份证不符合规则，要求：\n" +
                                "\u200B 长度为18位\n" +
                                "\u200B 不能以0为开头\n" +
                                "\u200B 前17位，必须都是数字\n" +
                                "\u200B 最为一位可以是数字，也可以是大写X或小写x\n"+
                                "请重新输入！");
                    }

                }
                else{
                    System.out.println("身份证号位数错误，请重新输入" );
                }
            }
            //录入手机号
            loop04:while (true) {
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入手机号：");
                String phoneNumber = sc.next();
                //要求1：长度为11位
                if(phoneNumber.length() == 11){
                    boolean standard = judgePhoneNumberStandard(phoneNumber);
                    if(standard){
                        System.out.println("手机号添加成功！");
                        user.setPhoneNumber(phoneNumber);
                        break loop04;
                    }
                    else{
                        System.out.println("手机号添加失败，请重新输入！要求：\n" +
                                "\u200B 长度为11位\n" +
                                "\u200B 不能以0为开头\n" +
                                "\u200B 必须都是数字");
                    }

                }
                else{
                    System.out.println("您输入的手机号位数有误，请重新输入11位的手机号!");
                }
            }
            //所有循环都能结束，则将对象添加进集合
            userList.add(user);
            break loop;
        }
    }

loginUser方法：

//用户登陆
    public static boolean loginUser(ArrayList <User> userList){
        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户名：");
            String username = sc.next();
            //判断用户名是否存在
            boolean flag = judgeUserNameOnly(userList, username);
            if(flag){
                //一共三次机会
                for(int i = 0;i < 3;i++) {
                    System.out.println("用户名存在！请输入密码：");
                    String userPasswords = sc.next();
                    //判断用户名密码是否正确
                    boolean flag01 = judgePassNumber(userList, userPasswords, username);
                    if(flag01){
                        System.out.println("密码正确！");
                        //输入验证码，每次循环获取一次验证码，直至验证码输对为止
                        while (true) {
                            String code1 = getCode();
                            System.out.println("获取验证码："+code1);
                            String code = sc.next();
                            //对比用户输入和系统随机生成的验证码，对比规则忽略大小写
                            if(code.equalsIgnoreCase(code1))
                            {
                                //验证码输入正确返回true值退出登陆模块
                                return true;
                            }
                            else{
                                System.out.println("验证码错误!请重新输入");
                            }
                        }
                    }
                    else{
                        System.out.println("密码错误，请重新输入,您还有"+(3-i-1)+"次机会");
                    }
                }
            }
            else{
                System.out.println("用户未注册，请先注册");
                return false;
            }
        }

    }

forgetPassword方法：

    //忘记密码
    public static void forgetPassword(ArrayList <User> userList){
        Scanner sc = new Scanner(System.in);
        //输入用户名
        System.out.println("请输入要修改的用户名");
        String username = sc.next();
        //判断用户是否存在
        boolean flag = judgeUserNameOnly(userList, username);
        if(flag){
            System.out.println("请输入该用户的身份证号：");
            String personId = sc.next();
            System.out.println("请输入该用户的手机号码：");
            String phoneNumber = sc.next();
            //修改密码
            getPersonIdIndex(personId,phoneNumber,userList);
        }
        else{
            System.out.println("该用户未注册！请注册");
            return;
        }

    }

judgeUserNameOnly方法：

//判断用户名唯一性性
    public static boolean judgeUserNameOnly(ArrayList <User> userList,String username){
        //遍历集合
        for (int i = 0; i < userList.size(); i++) {

            User user = userList.get(i);
            if(username.equals(user.getUsername())){
                return true;
            }
        }
        return false;

    }

judgeUserNameStandard方法：

 //判断用户名是否规范
    public static boolean judgeUserNameStandard(String username){
        int countNum  = 0;
        int countWords = 0;
        //遍历用户字符串，获取字符串中的每一个字符，统计数字个数，字母个数
        for (int i = 0; i < username.length(); i++) {
            char user = username.charAt(i);
            if(user >= '0'&&user <= '9'){
                countNum++;
            }
            else if(user >= 'a'&&user <= 'z'){
                countWords++;
            }
            else if(user >= 'A'&&user <= 'Z'){
                countWords++;
            }
        }
        //字母个数+数字个数=字符串长度，而且字母个数和数字个数不为零，则符合用户名规范
        if(countWords+countNum == username.length()&&countWords > 0&&countNum>0){
            return true;
        }
        else{
            return false;
        }
    }

judgePersonIdStandard方法：

 //判断身份证号是否规范
    public static boolean judgePersonIdStandard(String personId){
        //要求1：不能以0为开头
        char words0 = personId.charAt(0);
        int count = 0;
        if(words0 == '0'){
            return false;
        }
        else{
            //要求2：前17位必须是数字
            for (int i = 0; i < personId.length()-1; i++) {
                char words = personId.charAt(i);
                if(words >= '0'&&words <='9'){
                    count++;
                }
            }
            //要求3：最后一位可以是数字，也可以是大写X或小写x
            char wordsLast = personId.charAt(personId.length() - 1);
            if(wordsLast >='0'&&wordsLast <='9'){
                count++;
            }
            else if(wordsLast == 'X'||wordsLast == 'x'){
                count++;
            }

        }
        if(count == 18){
            return true;
        }
        return false;

    }

judgePhoneNumberStandard方法：

//判断手机号录入是否规范
    public static boolean judgePhoneNumberStandard(String phoneNumber){
        char words0 = phoneNumber.charAt(0);
        if(words0 == '0'){
            System.out.println("手机号开头不能为0,请重新输入!");
            return false;
        }
        else{
            //遍历字符串，找不是数字的
            for (int i = 0; i < phoneNumber.length(); i++){
                char words = phoneNumber.charAt(i);
                if(words >= '0'&&words <= '9'){
                    return true;
                }
            }
        }
        return false;
    }

judgePassNumber方法：

//判断密码是否正确密码
    public static boolean judgePassNumber(ArrayList <User> userList,String password,String username){
        int index = -1;
        //遍历集合根据用户名找索引
        for (int i = 0; i < userList.size(); i++) {
            //
           if(username.equals(userList.get(i).getUsername())){
               index = i;
           }
        }
        //判断用户名对应的密码是否相同
        if(password.equals(userList.get(index).getPassword())){
            return true;
        }
        return false;
    }

getCode方法：

//获取验证码
    public static String getCode(){
        //将26个大小写英文字母添加到字符数组中
        char [] chs = new char[52];
        for (int i = 0; i < chs.length; i++) {
            //添加大小写字母
            if(i <= 25){
                chs[i] = (char)(97+i);
            }
            else{
                chs[i] = (char) (65+i-26);
            }
        }
        //生成随机数
        Random r =new Random();
        String code = "";
        //添加4个字母
        for(int i =0 ; i < 4 ; i++){
            //生成随机索引
            int index = r.nextInt(52);
            //将索引对应的元素添加进字符串
            code = code + chs[index];
        }
        int num = r.nextInt(10);
        //添加数字
        code = code+num;
        //打乱字符串
        char[] chars = code.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            int index = r.nextInt(chars.length);
            char temp = chars[i];
            chars[i] = chars[index];
            chars[index] = temp;
        }
        String result = new String(chars);
        return result;

    }

getPersonIdinde方法：

//判断身份证和手机号是否一致并修改密码
    public static void getPersonIdIndex(String personId,String phoneNumber,ArrayList<User> userList){
        Scanner sc = new Scanner(System.in);
        //遍历集合取出集合元素
        for (int i = 0; i < userList.size(); i++) {
            User user = userList.get(i);
            //与集合中的每一个user对象比较身份证号和手机号
            if(personId.equals(user.getPersonId())&&phoneNumber.equals(user.getPhoneNumber())){
                //匹配成功，修改手机号
                System.out.println("信息匹配！请输入您要修改的密码：");
                String passwords = sc.next();
                user.setPassword(passwords);
                System.out.println("修改成功！");
                return;
            }
        }
        System.out.println("修改失败！账号信息不匹配" );
        return;
    }

StudentManagementSystem类:

所有代码如下：

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class StudentManagementSystem {
    public static void main(String[] args) {
        //创建集合存储学生信息
        ArrayList <Student> list = new ArrayList<>();
        //创建集合存储用户信息
        ArrayList <User> userList = new ArrayList<>();
        Scanner sc = null;

        loop:while (true) {
            //欢迎界面
            System.out.println("欢迎来到学生管理系统");
            System.out.println("请选择操作1登录 2注册 3忘记密码");
            //输入选项
            sc = new Scanner(System.in);
            String choose = sc.next();
            switch (choose){
                //登陆
                case "1":
                    boolean flag = loginUser(userList);
                    if(flag){
                        break loop;
                    }
                    break ;
                //注册
                case "2":
                    registerUser(userList);
                    break;
                //忘记密码
                case "3":
                    forgetPassword(userList);
                    break ;
                default:
                    System.out.println("该选项不存在，请重新选择");
                    break;
            }
        }

        while (true) {
            welcome();
            System.out.println("请输入您的选择：");
            String choose = sc.next();
            switch (choose){
                //添加学生
                case "1":
                    addStudent(list);
                    break;
                //删除学生
                case "2":
                    deleteStudent(list);
                    break;
                //修改学生
                case "3":
                    updateStudent(list);
                    break;
                //查询学生
                case "4":
                    queryStudent(list);
                    break;
                //退出系统
                case "5":
                    System.exit(0);//停止虚拟机运行
                default:
                    System.out.println("输入错误，请重新输入");
                    break;
            }
        }
    }
    //打印欢迎界面
    public static void welcome(){
        //打印欢迎界面
        System.out.println("---------------欢迎来到学生管理系统----------------");
        System.out.println("1：添加学生");
        System.out.println("2：删除学生");
        System.out.println("3：修改学生");
        System.out.println("4：查询学生");
        System.out.println("5：退出");
    }
    //添加学生
    public static void addStudent(ArrayList <Student> list){
        Scanner sc = new Scanner(System.in);
        //新建学生对象
        Student student = new Student();
        //添加id
        String id = null;
        //用一个循环添加id，
        while (true) {
            System.out.println("请添加id：");
            id = sc.next();
            //判断id的唯一性
            if(judgeOnly(list,id)){
                //不唯一则提示添加失败，继续循环直至添加成功
                System.out.println("添加失败，已经有该id");
            }
            //唯一则添加完id结束循环
            else{
                student.setId(id);
                break;
            }

        }
        //添加年龄
        System.out.println("请添加年龄：");
        int age = sc.nextInt();
        student.setAge(age);
        //添加姓名
        System.out.println("请添加姓名：");
        String name = sc.next();
        student.setName(name);
        //添加家庭住址
        System.out.println("请添加家庭住址：");
        String address = sc.next();
        student.setAddress(address);
        list.add(student);

    }
    //删除学生
    public static void deleteStudent(ArrayList <Student> list){
        Scanner sc =new Scanner(System.in);
        System.out.println("请输入要删除的学生id：");
        String id =sc.next();
        boolean flag = judgeOnly(list, id);
        //判断是否存在相同id，如果存在，就删除
        if(flag){
            //遍历集合，找相同id索引
            for (int i = 0; i < list.size(); i++) {

                Student student = list.get(i);
                if(id.equals(student.getId())){
                    //找到索引，用集合remove方法移除该索引对应元素
                    list.remove(i);
                }
            }
        }
        else{
            System.out.println("不存在该id");
            return;
        }
    }
    //修改学生
    public static void updateStudent(ArrayList <Student> list){
        Scanner sc =new Scanner(System.in);
        System.out.println("请输入要修改的学生id：");
        String id = sc.next();
        //判断id是否存在
        boolean flag = judgeOnly(list, id);
        if(flag){
            //存在则修改id
            System.out.println("该学生存在，请输入要修改的学生信息：");
            //创建一个新的学生对象
            Student newStudent = new Student();
            //将原id传递给新学生对象
            newStudent.setId(id);
            System.out.println("请输入学生的姓名：");
            String name = sc.next();
            newStudent.setName(name);
            System.out.println("请输入学生的年龄：");
            int age = sc.nextInt();
            newStudent.setAge(age);
            System.out.println("请输入学生的家庭住址：");
            String address = sc.next();
            newStudent.setAddress(address);
            //遍历集合，获取id相同的索引
            for (int i = 0; i < list.size(); i++) {

                Student student = list.get(i);
                if(id.equals(student.getId())){
                    list.set(i,newStudent);
                }
            }
        }
        else{
            System.out.println("不存在该id");
            return;
        }

    }
    //查询学生
    public static void queryStudent(ArrayList <Student> list){
        if(list.size() == 0){
            System.out.println("当前无学生信息，请添加后再查询");
            return;
        }
        else{
            System.out.println("id"+"\t\t"+"姓名"+"\t\t"+"年龄"+"\t\t"+"家庭住址");
            for (int i = 0; i < list.size(); i++) {
               Student student = list.get(i);
                System.out.println(student.getId()+"\t\t"+student.getName()+"\t\t"+student.getAge()+"\t\t"+student.getAddress());

            }
        }

    }
    //判断唯一性
    public static boolean judgeOnly(ArrayList <Student> list,String id){
        //遍历集合
        for (int i = 0; i < list.size(); i++) {

           Student student = list.get(i);
           if(id.equals(student.getId())){
               return true;
           }
        }
        return false;

    }
    //输出id相同的索引
    public static int returnIndex(ArrayList <Student> list,String id){
        for (int i = 0; i < list.size(); i++) {

            Student student = list.get(i);
            if(id.equals(student.getId())){
                return i;
            }
        }
        return -1;
    }
    //注册用户
    public static void registerUser(ArrayList <User> userList){
        loop:while (true) {
            User user = new User();
            //创建用户名
            loop01:while (true) {
                System.out.println("请输入要创建的用户名：");
                Scanner sc = new Scanner(System.in);
                //输入用户名
                String username = sc.next();
                //判断用户名唯一性
                boolean flag = judgeUserNameOnly(userList, username);
                //创建用户对象

                if(flag){
                    System.out.println("已有该用户，请重新输入!");
                }
                else{
                    //要求2：长度必须在3~15之间
                    if(username.length()<3&&username.length()>15){
                        System.out.println("用户名长度必须为3~15位，您的用户名长度不符合要求，请重新输入!");
                    }
                    else {
                        //要求3：只能是数字加字母，不能是纯数字
                        //1.判断输入的用户名是否在0~9,a~z,A~Z
                        boolean standardFlag = judgeUserNameStandard(username);
                        if(standardFlag){
                            System.out.println("用户名创建成功");
                            user.setUsername(username);
                            break loop01;

                        }
                        else {
                            System.out.println("不符合用户名规范，用户名只能是字母加数字的组合，不能是纯数字或纯字母");
                        }

                    }
                }

            }
            //创建密码
            loop02:while (true) {
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入用户密码：");
                String userPassword01 = sc.next();
                System.out.println("请再次输入用户密码：");
                String userPassword02 =sc.next();
                //验证两次密码是否一致
                if(userPassword02.equals(userPassword01)){
                    System.out.println("密码创建成功！");
                    //将密码添加进user对象
                    user.setPassword(userPassword01);
                    //跳出loop02循环
                    break loop02;
                }
                else{
                    System.out.println("两次密码输入的不一致，请重新创建密码！");
                }
            }
            //录入身份证号
            loop03:while (true) {
                System.out.println("请输入身份证号：");
                Scanner sc = new Scanner(System.in);
                String personId = sc.next();
                //如果身份证号长度等于18位，进行之后操作
                if(personId.length() == 18){
                    //判断身份证号是否符合规范
                    boolean standard = judgePersonIdStandard(personId);
                    if(standard){
                        user.setPersonId(personId);
                        System.out.println("身份证添加成功！");
                        break loop03;
                    }
                    else{
                        System.out.println("您输入的身份证不符合规则，要求：\n" +
                                "\u200B 长度为18位\n" +
                                "\u200B 不能以0为开头\n" +
                                "\u200B 前17位，必须都是数字\n" +
                                "\u200B 最为一位可以是数字，也可以是大写X或小写x\n"+
                                "请重新输入！");
                    }

                }
                else{
                    System.out.println("身份证号位数错误，请重新输入" );
                }
            }
            //录入手机号
            loop04:while (true) {
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入手机号：");
                String phoneNumber = sc.next();
                //要求1：长度为11位
                if(phoneNumber.length() == 11){
                    boolean standard = judgePhoneNumberStandard(phoneNumber);
                    if(standard){
                        System.out.println("手机号添加成功！");
                        user.setPhoneNumber(phoneNumber);
                        break loop04;
                    }
                    else{
                        System.out.println("手机号添加失败，请重新输入！要求：\n" +
                                "\u200B 长度为11位\n" +
                                "\u200B 不能以0为开头\n" +
                                "\u200B 必须都是数字");
                    }

                }
                else{
                    System.out.println("您输入的手机号位数有误，请重新输入11位的手机号!");
                }
            }
            //所有循环都能结束，则将对象添加进集合
            userList.add(user);
            break loop;
        }
    }
    //用户登陆
    public static boolean loginUser(ArrayList <User> userList){
        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户名：");
            String username = sc.next();
            //判断用户名是否存在
            boolean flag = judgeUserNameOnly(userList, username);
            if(flag){
                //一共三次机会
                for(int i = 0;i < 3;i++) {
                    System.out.println("用户名存在！请输入密码：");
                    String userPasswords = sc.next();
                    //判断用户名密码是否正确
                    boolean flag01 = judgePassNumber(userList, userPasswords, username);
                    if(flag01){
                        System.out.println("密码正确！");
                        //输入验证码，每次循环获取一次验证码，直至验证码输对为止
                        while (true) {
                            String code1 = getCode();
                            System.out.println("获取验证码："+code1);
                            String code = sc.next();
                            //对比用户输入和系统随机生成的验证码，对比规则忽略大小写
                            if(code.equalsIgnoreCase(code1))
                            {
                                //验证码输入正确返回true值退出登陆模块
                                return true;
                            }
                            else{
                                System.out.println("验证码错误!请重新输入");
                            }
                        }
                    }
                    else{
                        System.out.println("密码错误，请重新输入,您还有"+(3-i-1)+"次机会");
                    }
                }
            }
            else{
                System.out.println("用户未注册，请先注册");
                return false;
            }
        }

    }
    //忘记密码
    public static void forgetPassword(ArrayList <User> userList){
        Scanner sc = new Scanner(System.in);
        //输入用户名
        System.out.println("请输入要修改的用户名");
        String username = sc.next();
        //判断用户是否存在
        boolean flag = judgeUserNameOnly(userList, username);
        if(flag){
            System.out.println("请输入该用户的身份证号：");
            String personId = sc.next();
            System.out.println("请输入该用户的手机号码：");
            String phoneNumber = sc.next();
            //修改密码
            getPersonIdIndex(personId,phoneNumber,userList);
        }
        else{
            System.out.println("该用户未注册！请注册");
            return;
        }

    }
    //判断用户名唯一性性
    public static boolean judgeUserNameOnly(ArrayList <User> userList,String username){
        //遍历集合
        for (int i = 0; i < userList.size(); i++) {

            User user = userList.get(i);
            if(username.equals(user.getUsername())){
                return true;
            }
        }
        return false;

    }
    //判断用户名是否规范
    public static boolean judgeUserNameStandard(String username){
        int countNum  = 0;
        int countWords = 0;
        //遍历用户字符串，获取字符串中的每一个字符，统计数字个数，字母个数
        for (int i = 0; i < username.length(); i++) {
            char user = username.charAt(i);
            if(user >= '0'&&user <= '9'){
                countNum++;
            }
            else if(user >= 'a'&&user <= 'z'){
                countWords++;
            }
            else if(user >= 'A'&&user <= 'Z'){
                countWords++;
            }
        }
        //字母个数+数字个数=字符串长度，而且字母个数和数字个数不为零，则符合用户名规范
        if(countWords+countNum == username.length()&&countWords > 0&&countNum>0){
            return true;
        }
        else{
            return false;
        }
    }
    //判断身份证号是否规范
    public static boolean judgePersonIdStandard(String personId){
        //要求1：不能以0为开头
        char words0 = personId.charAt(0);
        int count = 0;
        if(words0 == '0'){
            return false;
        }
        else{
            //要求2：前17位必须是数字
            for (int i = 0; i < personId.length()-1; i++) {
                char words = personId.charAt(i);
                if(words >= '0'&&words <='9'){
                    count++;
                }
            }
            //要求3：最后一位可以是数字，也可以是大写X或小写x
            char wordsLast = personId.charAt(personId.length() - 1);
            if(wordsLast >='0'&&wordsLast <='9'){
                count++;
            }
            else if(wordsLast == 'X'||wordsLast == 'x'){
                count++;
            }

        }
        if(count == 18){
            return true;
        }
        return false;

    }
    //判断手机号录入是否规范
    public static boolean judgePhoneNumberStandard(String phoneNumber){
        char words0 = phoneNumber.charAt(0);
        if(words0 == '0'){
            System.out.println("手机号开头不能为0,请重新输入!");
            return false;
        }
        else{
            //遍历字符串，找不是数字的
            for (int i = 0; i < phoneNumber.length(); i++){
                char words = phoneNumber.charAt(i);
                if(words >= '0'&&words <= '9'){
                    return true;
                }
            }
        }
        return false;
    }
    //判断密码是否正确密码
    public static boolean judgePassNumber(ArrayList <User> userList,String password,String username){
        int index = -1;
        //遍历集合根据用户名找索引
        for (int i = 0; i < userList.size(); i++) {
            //
           if(username.equals(userList.get(i).getUsername())){
               index = i;
           }
        }
        //判断用户名对应的密码是否相同
        if(password.equals(userList.get(index).getPassword())){
            return true;
        }
        return false;
    }
    //获取验证码
    public static String getCode(){
        //将26个大小写英文字母添加到字符数组中
        char [] chs = new char[52];
        for (int i = 0; i < chs.length; i++) {
            //添加大小写字母
            if(i <= 25){
                chs[i] = (char)(97+i);
            }
            else{
                chs[i] = (char) (65+i-26);
            }
        }
        //生成随机数
        Random r =new Random();
        String code = "";
        //添加4个字母
        for(int i =0 ; i < 4 ; i++){
            //生成随机索引
            int index = r.nextInt(52);
            //将索引对应的元素添加进字符串
            code = code + chs[index];
        }
        int num = r.nextInt(10);
        //添加数字
        code = code+num;
        //打乱字符串
        char[] chars = code.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            int index = r.nextInt(chars.length);
            char temp = chars[i];
            chars[i] = chars[index];
            chars[index] = temp;
        }
        String result = new String(chars);
        return result;

    }
    //判断身份证和手机号是否一致并修改密码
    public static void getPersonIdIndex(String personId,String phoneNumber,ArrayList<User> userList){
        Scanner sc = new Scanner(System.in);
        //遍历集合取出集合元素
        for (int i = 0; i < userList.size(); i++) {
            User user = userList.get(i);
            //与集合中的每一个user对象比较身份证号和手机号
            if(personId.equals(user.getPersonId())&&phoneNumber.equals(user.getPhoneNumber())){
                //匹配成功，修改手机号
                System.out.println("信息匹配！请输入您要修改的密码：");
                String passwords = sc.next();
                user.setPassword(passwords);
                System.out.println("修改成功！");
                return;
            }
        }
        System.out.println("修改失败！账号信息不匹配" );
        return;
    }
    //测试方法
    public static void test(ArrayList <User> userList){
        for (int i = 0; i < userList.size(); i++) {
            User user = userList.get(i);
            System.out.println("用户名："+user.getUsername()+"密码："+user.getPassword()+"身份证号："+user.getPersonId()+"手机号："+user.getPhoneNumber());
        }
    }
}

不足：

逻辑过于基础导致代码冗余，有一些重复地方，可以多写几个方法避免冗余。

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ZEALERHE

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值