JAVA练习题32：学生管理系统升级版-CSDN博客

本文链接：https://blog.csdn.net/m0_46457497/article/details/127330783

新增加了主页，包括用户注册，登录，忘记密码和退出功能。只有登录成功才能进到学生管理系统

所有代码： https://pan.baidu.com/s/1u7csVCP4bESALds2cwWEPg?pwd=pszs
提取码: pszs

学生管理系统升级版

需求：

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

分析：

登录界面：

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

用户类：

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

注册功能：

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

登录功能：

键盘录入用户名
键盘录入密码
键盘录入验证码

验证要求：

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

忘记密码：

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

验证码规则：

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

代码实现

1. 学生管理系统主页类（用户登录，注册，更改密码和退出）

欢迎来到学生管理系统
请选择操作 1 登录 2 注册 3 忘记密码 4 退出：

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

public class App {
    public static void main(String[] args) {
        ArrayList<User> list = new ArrayList<>();
        //先添加以及用户数据用来测试
        User user1 = new User("zhangsan","1234qwer","354669988741256328","18956971456");
        User user2 = new User("lisi","1234q","354669988741257895","18569871456");
        User user3 = new User("wangwu","1234qe","354669988741258569","18925361456");
        list.add(user1);
        list.add(user2);
        list.add(user3);
        Scanner sc = new Scanner(System.in);
        loop:while (true) {
            System.out.println("欢迎来到学生管理系统");
            System.out.println("请选择操作 1 登录 2 注册 3 忘记密码 4 退出：");
            String choose = sc.next();   //使用字符串接收，提高容错率
            switch (choose){
                case "1":
                    login(list);
                    break;
                case "2":
                    register(list);
                    break;
                case "3":
                    forgetPassword(list);
                    break;
                case "4":
                    System.out.println("退出");
                    break loop;
                default:
                    System.out.println("输入数据不合法！");
            }
        }
    }

    /**
     * 方法：注册
     * 用户名，密码，身份证号码，手机号码放到用户对象中
     * 把用户对象添加到集合中。
     */
    public static void register(ArrayList<User> list){
        Scanner sc = new Scanner(System.in);
        //1.键盘录入用户名
        String username;
        while (true) {
            System.out.println("请输入用户名：");
            username = sc.next();
            //开发细节：先验证格式是否正确，再验证是否唯一。
            //         因为在以后所有的数据，都是存储在数据库中，如果我们需要校验，则需要使用到网络资源。所以放在后面进行。
            //用户名长度必须在3-15位之间
            //只能是字母加数字的组合，但不能是纯数字
            boolean name_flag1 = checkUsername(username);
            if (!name_flag1){
                System.out.println("用户名格式不满足条件，需要重新输入");
                //结束本次循环
                continue;
            }
            //校验用户名唯一
            //用户名是否已存在。已存在：true  不存在：false
            boolean name_flag2 = contains(list,username);
            if (name_flag2){
                //用户名已存在，那么则无法注册
                System.out.println("当前用户名" + username + "已经存在，请重新输入");
                //这里也可以不要continue;因为如果用户名已经存在，这里没有break，循环会正常进行下去，继续循环。
                continue;

            }else {
                //不存在，表示当前用户名可用，可以继续录入其他的数据
                System.out.println("用户名" + username + "可用");
                break;
            }

        }
        //2.键盘录入密码
        String firstPassword;
        String secondPassword;
        while (true) {
            System.out.println("请输入密码：");
            firstPassword = sc.next();
            System.out.println("请确认密码：");
            secondPassword = sc.next();
            if (firstPassword.equals(secondPassword)){
                System.out.println("密码输入成功");
                break;
            }else {
                System.out.println("两次密码不一致，无法注册！请重新输入");
            }
        }
        //3.键盘录入身份证号码
        String personId;
        while (true) {
            System.out.println("请输入身份证号码：");
            personId = sc.next();
            boolean personId_flag = checkPersonID(personId);
            if (personId_flag){
                System.out.println("身份证号码满足要求");
                break;
            }else {
                System.out.println("身份证号码格式有误，请重新输入");
            }
        }
        //4.键盘录入手机号码
        String phoneNumber;
        while (true) {
            System.out.println("请输入手机号码");
            phoneNumber = sc.next();
            boolean phoneNumber_flag = checkPhoneNumber(phoneNumber);
            if (phoneNumber_flag){
                System.out.println("手机号码格式正确");
                break;
            }else {
                System.out.println("手机号码格式有误，请重新输入");
            }
        }

        //用户名，密码，身份证号码，手机号码放到用户对象中
        User user = new User(username,firstPassword,personId,phoneNumber);
        //把用户对象添加到集合中。
        list.add(user);
        //遍历集合(测试用)
        printList(list);
    }

    /**
     * 方法1：用户名是否合法
     *  用户名长度必须在3-15位之间
     *  只能是字母加数字的组合，但不能是纯数字
     */
    private static boolean checkUsername(String username) {
        int len = username.length();   //采用赋值的方式使length()方法只调用一次,提升效率
        //用户名长度必须在3-15位之间
        if(len < 3 || len > 15){
            return false;
        }
        //当代码执行到这里，表示用户名的长度是符合要求的
        //继续校验：只能是字母加数字的组合
        //循环得到username里面的每一个字符，如果有一个字符不是字母或数字，那么就返回false
        for (int i = 0; i < len; i++) {
            char c = username.charAt(i);
            //c_flag为true --> username是只包含字母或数字的组合
            //c_flag为false --> username还包含其他符号
            boolean c_flag = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9');
            if (!c_flag) {
                return false;
            }
        }
        //当代码执行到这里，表示用户名满足了两个要求：1 长度满足  2 内容也满足（字母+数字）
        //但不能是纯数字
        //遍历字符串,确定里面有多少数字。
        int count = 0;
        for (int i = 0; i < len; i++) {
            if(username.charAt(i) >= '0' && username.charAt(i) <= '9'){
                count++;
            }
        }
        //count < len为true时，用户名不为纯数字，此时用户名长度为3-15之间，并且只包含字母和数字。
        return count < len;
        /**
         * 用户名不能是纯数字的第二种判断方法
         * */
        /*int count = 0;
        for (int i = 0; i < len; i++) {
            char c = username.charAt(i);
            if((c >= 'a' && c <= 'z') ||(c >= 'A' && c <= 'Z')){
                count++;
                //只要用户名中出现字符，就证明不是纯数字。则可以不继续遍历。提升效率
                break;
            }
        }
        //count > 0为true时，用户名不为纯数字，此时用户名长度为3-15之间，并且只包含字母和数字。
        return count > 0;*/

    }

    /**
     *方法2：判断用户名是否已存在
     *  存在：true
     *  不存在：false
     */
    public static boolean contains(ArrayList<User> list, String username){
        //循环遍历集合得到里面的每一个用户对象
        for (int i = 0; i < list.size(); i++) {
            //拿到用户对象后，获取username并进行判断
            String u_username = list.get(i).getUsername();
            if (username.equals(u_username)){
                //存在：true
                return true;
            }
        }
        //不存在：false
        return false;
    }

    /**
     *方法3：身份证号码是否合法。
     *  长度为18位
     *  不能以0为开头
     *  前17位，必须都是数字
     *  最后一位可以是数字，也可以是大写X或小写x
     * */
    private static boolean checkPersonID(String  personId) {
        //长度为18位
        if (personId.length() != 18){
            return false;
        }
        //不能以0为开头
        //startWith(str)方法是用来判断是否以str开头
        // 如果是，则返回true
        if(personId.startsWith("0")){
            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 == 'X' || endChar == 'x' || (endChar >= '0' && endChar <= '9')){
            return true;
        }else{
            return false;
        }
    }

    /**
     *方法4：手机号码是否合法。
     * 长度为11位
     * 不能以0为开头
     * 必须都是数字
     * */
    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;
    }

    /**
     *方法：登录
     *键盘录入用户名
     *键盘录入密码
     *键盘录入验证码
     *用户名如果未注册，直接结束方法，并提示：用户名未注册，请先注册
     *判断验证码是否正确，如不正确，重新输入
     *再判断用户名和密码是否正确，有3次机会
     * */
    public static void login(ArrayList<User> list){
        Scanner sc = new Scanner(System.in);
        //只有3次机会输入用户名和密码。三次之后锁定
        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 (rightCode.equalsIgnoreCase(code)){
                    System.out.println("验证码正确");
                    break;
                }else{
                    System.out.println("验证码错误，请重新输入！");
                }
            }

            //验证用户名和密码是否正确
            //集合中是否包含用户名和密码
            //定义一个方法验证用户名和密码是否正确
//        封装思想的应用
//        可以把一些零散的数据，封装成一个对象
//        以后传递参数的时候，只要传递一个整体就可以了，不需要管这些零散的数据。
            User userInfo = new User(username,password,null,null);
            boolean result = checkUserInfo(list,userInfo);
            if(result){
                System.out.println("登录成功，可以开始使用学生管理系统了");
                //创建学生管理类的对象，调用方法，启动学生管理系统
                StudentSystem ss = new StudentSystem();
                ss.startStudentSystem();
                break;
            }else{
                System.out.println("登录失败，用户名或密码错误！");
                if(i == 2){
                    System.out.println("当前账户：" + username + "被锁定，请练习xxx-xxxxx");
                    //当前账户锁定之后，直接结束方法即可
                    return;
                }else{
                    System.out.println("用户名或密码错误，还剩下" + (2-i) + "次机会");
                }
            }

        }
    }
    /**
     * 方法1：生成验证码
     *      长度为5
     *      由4位大写或者小写字母和1位数字组成，同一个字母可重复
     *      数字可以出现在任意位置
     *      比如：aQa1K
     */
    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));
        }
        //2.随机抽取4个字符
        StringBuilder sb = new StringBuilder();
        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);

    }

    /**
    * 方法2：验证userInfo的用户名和密码是否正确
    * */
    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;
    }

    /**
     *方法：忘记密码
     *   键盘录入用户名，判断当前用户名是否存在，如不存在，直接结束方法，并提示：未注册
     *   键盘录入身份证号码和手机号码
     *   判断当前用户的身份证号码和手机号码是否一致，
     *   如果一致，则提示输入密码，进行修改。
     *   如果不一致，则提示：账号信息不匹配，修改失败。
     * */
    public 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().equalsIgnoreCase(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("两次密码输入不一致，请重新输入");
            }
        }

        //直接修改即可
        user.setPassword(password);
        System.out.println("密码修改成功");
    }

    /**
     * 方法1：返回用户名为username的对象在list里的索引位置
     */
    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;
    }

    //遍历集合(测试用)   //对应124行
    private static void printList(ArrayList<User> list) {
        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            System.out.println("username=" + user.getUsername() + ", password=" + user.getPassword() +
                    ", personId=" + user.getPersonId() + ", phoneNumber=" + user.getPhoneNumber());
        }
    }

}

2. 用户类

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;
    }

}

3. 学生管理类

"-------------欢迎来到学生管理系统----------------"
"1：添加学生"
"2：删除学生"
"3：修改学生"
"4：查询学生"
"5：退出"
"请输入您的选择:"

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

public class StudentSystem {
    public static void startStudentSystem() {
        /*
         * 学生管理系统
         * */
        //创建学生集合
        ArrayList<Student> list = new ArrayList<>();
        loop: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);
            //使用next接收数据，这样程序不会报错，接收进来后再进行判断。如果使用nextInt进行接收，输入数据不适合时，程序会报错。
            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.out.println("退出");
                    break loop;
                default:
                    System.out.println("输入数据不合法！");
            }
        }

    }

    //添加学生
    public static void addStudent(ArrayList<Student> list){
        //将属性添加到学生对象中。每次都会创建一个新的对象出来
        Student s = new Student();
        Scanner sc = new Scanner(System.in);
        //id
        while (true) {
            System.out.println("请输入学生的id：");
            String id = sc.next();
            boolean flag = contains(list, id);
            if (flag){
                //表示id已经存在，需要重新录入
                System.out.println("当前id已存在，请重新录入!");
            }else{
                //表示id不存在，即可以使用
                s.setId(id);
                break;
            }
        }
        //name
        System.out.println("请输入学生的姓名：");
        String name = sc.next();
        s.setName(name);
        //age
        System.out.println("请输入学生的年龄：");
        int age = sc.nextInt();
        s.setAge(age);
        //address
        System.out.println("请输入学生的家庭住址：");
        String address = sc.next();
        s.setAddress(address);


        //将学生对象添加到集合当中
        list.add(s);

        //因为list.add只要数据类型正确，就只会添加成功。所以可以提示以下用户
        System.out.println("学生信息添加成功");    //如果数据类型不正确，则会直接在控制台报错，程序都运行不成功。
    }

    //删除学生
    public static void deleteStudent(ArrayList<Student> list){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要删除学生的id:");
        String id = sc.next();
        //查询id在集合中的索引
        int index = getIndex(list,id);
        //对index进行判断
        if(index >= 0){
            //如果大于等于0的，就表示存在，直接删除
            list.remove(index);
            System.out.println("id为：" + id + "的学生删除成功！");
        }else{
            //如果为-1，则表示不存在，直接结束方法即可。回到初始菜单
            System.out.println("id不存在，删除失败");
        }
    }

    //修改学生
    public static void updateStudent(ArrayList<Student> list){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要修改学生的id:");
        String id = sc.next();
        //获取id在集合的索引位置
        int index = getIndex(list,id);

        if(index == -1){
            System.out.println("要修改的学生" + id +"不存在，请重新输入");
            return;
        }
        //当代码执行到这里，表示当前id是存在集合里的
        //获取要修改的学生对象
        Student stu = list.get(index);
        //输入其他的信息并修改
        System.out.println("请输入要修改的学生姓名：");
        String newName = sc.next();
        stu.setName(newName);

        System.out.println("请输入要修改的学生年龄：");
        int newAge = sc.nextInt();
        stu.setAge(newAge);

        System.out.println("请输入要修改的学生家庭住址：");
        String newAddress = sc.next();
        stu.setAddress(newAddress);

        System.out.println("学生信息修改成功。");
    }

    //查询学生
    public static void queryStudent(ArrayList<Student> list){
        if (list.size() == 0){
            System.out.println("当前无学生信息，请添加后再查询");
            //结束方法
            return;
        }
        //当代码执行到这里，表示集合中是有数据的
        //打印表头信息。制表符\t会给前面的数据自动补齐成8位或8的倍数位。\t只与前面邻接的数据有关，与后面的邻接数据无关
        System.out.println("id\t\t姓名\t年龄\t家庭住址\t");
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getId() + "\t\t" + stu.getName() + "\t" + stu.getAge() + "\t" + stu.getAddress());
        }
    }

    //判断id在集合中是否存在
    //存在：true
    //不存在：false
    public static boolean contains(ArrayList<Student> list, String id){
       /* //循环遍历集合得到里面的每一个学生对象
        for (int i = 0; i < list.size(); i++) {
            //拿到学生对象后，获取id并进行判断
            String sid = list.get(i).getId();
            if (id.equals(sid)){
                //存在：true
                return true;
            }
        }
        //不存在：false
        return false;*/
        //存在：true
        //不存在：false
       return getIndex(list,id) >= 0;
    }
    //通过id获取索引的方法
    public static int getIndex(ArrayList<Student> list, String id){
        //循环遍历集合得到里面的每一个学生对象
        for (int i = 0; i < list.size(); i++) {
            //拿到学生对象后，获取id并和要查询的id进行比较
            String sid = list.get(i).getId();
            if (id.equals(sid)){
                //如果一样，那么就返回索引
                return i;
            }
        }
        //当循环结束之后还没有找到，就表示不存在，返回-1
        return -1;
    }
}

4. 学生类

public class Student{
    private String id;    //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;
    }

    public String getId() {
        return id;
    }

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

    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 getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}