学生管理系统

一、登录

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

1、欢迎页面

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

代码实现：

    //欢迎页面
    public static void welcome(ArrayList<User> list){
        while (true) {
            System.out.println("欢迎来到学生管理系统");
            System.out.println("请选择操作:1登录 2注册 3忘记密码");
            //1.创建一个Scanner对象
            Scanner sc = new Scanner(System.in);
            //获取输入的信息
            System.out.println("请输入操作：");
            String operation = sc.next();
            switch (operation){
                case "1" -> login(list);
                case "2" -> register(list);
                case "3" -> forgetPassword(list);
                default -> System.out.println("请输入1-3数字中的一个！");
            }
        }
    }

2、注册功能

①变量的作用范围只在所属的大括号范围内有效。

要想在外面也有效，就要提升作用范围，可以将变量定义在大括号外面。

②如果同时要满足很多条件时怎么做？

正向考虑：即满足条件时一步步往下，但是这样有一个弊端，就是if-else可能会嵌套过深，当增加新的条件时代码不易维护。

反向考虑：即什么时候不满足条件return false；，直接结束方法的运行。

（1）用户名

满足以下3个条件：

①用户名唯一；

②用户名长度必须在3~15位之间；

③只能是字母加数字的组合，但是不能是纯数字。

对于用户名的判断：先验证格式，再验证唯一性。因为验证唯一性需要连接数据库，比较耗费资源。

对于要求3，我写的这个方法是判断是否存在大小写字母，以此来说明不是纯数字，这是因为我知道输入的时候会是字母和数字的组合，但是实际过程中是有可能会输入其他字符的，所以要加入输入的字符串只能是字母和数字的组合这个要求的实现。

    //判断用户名是否满足要求3
    public static boolean check3(String username){
        for (int i = 0; i < username.length(); i++) {
            char c = username.charAt(i);
            if((c > 'a') && (c < 'z')){
                return true;
            }
            if((c > 'A') && (c < 'Z')){
                return true;
            }
        }
        return false;
    }

实现验证用户名只能是字母和数字的组合的方法check31：当出现除字母和数字以外的字符时return false；遍历完所有字符都没有return false说明只有数字和字母。

   public static boolean check31(String username) {
        for (int i = 0; i < username.length(); i++) {
            //依次获取每一个字符
            char c = username.charAt(i);
            //取反说明当条件为假时return false
            //((c >= 'a') && (c <= 'z'))表示c是字符a-z之间的一个
            //而条件什么时候为假，即字符不是大小写英文字母和数字中的任意一个
            if (!(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) || ((c >= '0') && (c <= '9')))) {
                return false;
            }
        return true;
    }

然后加上是否有大小写字母的的方法check32：与刚开始的实现是一样的，只不过将判断大写和小写合并到一起了。

    //判断是否有大小写字母存在
    public static boolean check32(String username){
        for (int i = 0; i < username.length(); i++) {
            char c = username.charAt(i);
            if ((((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')))) {
                return true;
            }
        }
        return false;
    }

Ⅰ、输入用户名的判断

①在判断用户名的长度时，可以将username.length()提取处理赋给一个变量，提高效率。

在下面这个代码中应用的正向考虑：

    //判断用户名是否合法
    public static boolean checkUsername(ArrayList<User> list, String username) {
        int length = username.length();
        if ((3 <= length) && (length <= 15)) {
            if (check31(username)) {
                if (check32(username)){
                    return true;
                }
            }
        }
        return false;
    }

这里是修改后的代码，应用了视频中的反向考虑思想：

Ⅱ、用户名的输入

        while (true) {
            //获取输入的用户名
            System.out.println("请输入用户名：");
            String username = sc.next();
            
            //首先验证用户名的格式
            if (checkUsername(list, username)) {
                //满足条件时进行用户唯一性的判断
                if (contains(list, username)) {
                    //将输入的用户名与用户对象进行绑定
                    user.setUsername(username);
                    break;
                } else {
                    System.out.println("输入的用户名已存在！");
                }
            } else {
                System.out.println("用户名不合法！请重新输入");
            }
        }

这里if有两层嵌套，其实还可以，但是也可以修改为反向考虑的代码，这里就不写了。

关于后面的密码、身份证号和手机号等代码的反向考虑的修改就不赘述了。

（2）密码

密码键盘输入两次，两次一致才可以进行注册。

Ⅰ、密码的输入和判断

        while (true) {
            //获取输入的密码
            System.out.println("请输入密码：");
            String password1 = sc.next();
            System.out.println("请再次输入密码：");
            String password2 = sc.next();
            //将输入的密码与用户对象进行绑定
            if (password1.equals(password2)) {
                user.setPassword(password1);
                break;
            } else {
                System.out.println("两次输入的密码不一致！请重新输入");
            }
        }

（3）身份证号

身份证号码验证要求：

①长度为18位；

②不能以0为开头；

③前17位，必须都是数字；

④最为一位可以是数字，也可以是大写X或小写x。

Ⅰ、输入身份证号的判断

public static boolean checkID(String ID) {
        //获取ID的长度
        int length = ID.length();
        //判断长度是否为18
        if (length == 18) {
            //判断开头是否为0
            if (ID.charAt(0) != '0') {
                //获取最后一位
                char c1 = ID.charAt(length - 1);
                if (((c1 > '0') && (c1 < '9')) || (c1 == 'X') || (c1 == 'x')) {
                    //循环遍历前17位
                    for (int i = 0; i < length - 1; i++) {
                        char c2 = ID.charAt(i);
                        if ((c2 > '0') && (c2 < '9')) {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }

Ⅱ、身份证号的输入

       while (true) {
            //获取输入的身份证号
            System.out.println("请输入身份证号：");
            String ID = sc.next();
            //将输入的密码与用户对象进行绑定
            if (checkID(ID)) {
                user.setID(ID);
                break;
            } else {
                System.out.println("输入的身份证号不合法！请重新输入");
            }
        }

（4）手机号

验证要求：

①长度为11位

②不能以0为开头

③必须都是数字

Ⅰ、输入手机号的判断

 public static boolean checkPhoneNumber(String phoneNumber) {
        //获取手机号的长度
        int length = phoneNumber.length();
        //判断长度是否为11
        if (length == 11) {
            //判断开头是否为0
            if (phoneNumber.charAt(0) != '0') {
                //循环遍历前11位
                for (int i = 0; i < length; i++) {
                    char c2 = phoneNumber.charAt(i);
                    if ((c2 > '0') && (c2 < '9')) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

对于要求②，不仅可以使用phoneNumber.charAt(0)获取0位置的索引，还可以使用startWith方法验证是否以0开头。

Ⅱ、手机号的输入

        while (true) {
            //获取输入的手机号
            System.out.println("请输入手机号：");
            String phoneNumber = sc.next();
            //将输入的密码与用户对象进行绑定
            if (checkPhoneNumber(phoneNumber)) {
                user.setID(phoneNumber);
                break;
            } else {
                System.out.println("输入的手机号不合法！请重新输入");
            }
        }

然后将数据添加到集合中，并提示添加成功：

        list.add(user);
        System.out.println("添加成功！");

3、登录

（1）键盘录入用户名；

（2）键盘录入密码；

（3）键盘录入验证码。

验证要求：

用户名如果未注册，直接结束方法，并提示：用户名未注册，请先注册；

判断验证码是否正确，如不正确，重新输入；

再判断用户名和密码是否正确，有3次机会。

验证码要求：

（1）长度为5；

（2）由4位大写或者小写字母和1位数字组成，同一个字母可重复；

（3）数字可以出现在任意位置。

比如：

aQa1K

（1）生成验证码

刚开始我是把把52个大小写英文字母存到数组中，一个一个打出来的，很傻。

    // 生成验证码
    public static String createCaptcha() {
        //首先把52个大小写英文字母存到数组中
        String[] s = {"A", "B", "C", "D", "E", "F", "G",
                "H", "I", "J", "K", "L", "M", "N",
                "O", "P", "Q", "R", "S", "T",
                "U", "V", "W", "X", "Y", "Z",
                "a", "b", "c", "d", "e", "f", "g",
                "h", "i", "j", "k", "l", "m", "n",
                "o", "p", "q", "r", "s", "t",
                "u", "v", "w", "x", "y", "z"};
        //创建一个sb对象用来存字符串
        StringBuilder sb = new StringBuilder();
        //随机选择数组中的字母，循环4次生成4个
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            int index = r.nextInt(s.length);
            sb.append(s[index]);
        }
        //生成数字
        int number = r.nextInt(10);
        //生成数字插入的位置
        int position = r.nextInt(5);
        sb.insert(position, number);
        String captcha = sb.toString();
        return captcha;
    }

利用ASCII码添加大小写英文字母，这是修改了的代码：

    // 生成验证码
    public static String createCaptcha() {
        //创建一个sb对象用来存52个大小写英文字母
        StringBuilder sb1 = new StringBuilder();
        for (int i = 0; i < 26; i++) {
            char c1 = (char) ('a' + i);
            sb1.append(c1);
            char c2 = (char) ('A' + i);
            sb1.append(c2);
        }
        String string = sb1.toString();
        //创建一个sb对象用来存字符串
        StringBuilder sb2 = new StringBuilder();
        //随机选择数组中的字母，循环4次生成4个
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            int index = r.nextInt(string.length());
            sb2.append(string.charAt(index));
        }
        //生成数字
        int number = r.nextInt(10);
        //生成数字插入的位置
        int position = r.nextInt(5);
        sb2.insert(position, number);
        String captcha = sb2.toString();
        return captcha;
    }

（2）判断用户名和密码是否正确

    //判断用户名和密码是否正确
    public static boolean checkUsername_Password(ArrayList<User> list, String username, String password){
        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            if ((username.equals(user.getUsername())) && (password.equals(user.getPassword()))){
                return true;
            }
        }
        return false;
    }

由于这个方法传递的参数比较多，提供一种封装的思想，可以将属性封装到一个对象中进行传递。

    //判断用户名和密码是否正确
    public static boolean checkUserInfo(ArrayList<User> list, User user1){
        String username = user1.getUsername();
        String password = user1.getPassword();
        for (int i = 0; i < list.size(); i++) {
            User user2 = list.get(i);
            if ((username.equals(user2.getUsername())) && (password.equals(user2.getPassword()))){
                return true;
            }
        }
        return false;
    }

这个整个登录代码的实现：

1、首先输入用户名、密码、验证码；

2、判断用户名是否存在，不存在则提示用户名未注册，请先注册；

3、进行验证码的校验；

4、用户名和密码的判断；

    //登录
    public static void login(ArrayList<User> list) {
        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            //获取输入的信息
            System.out.println("请输入用户名：");
            String username = sc.next();
            System.out.println("请输入密码：");
            String password = sc.next();
            //生成验证码
            String captcha1 = createCaptcha();
            System.out.println("生成的验证码为：" + captcha1);
            System.out.println("请输入验证码：");
            String captcha2 = sc.next();
            //将此对象的username与集合中所有对象的username进行判断
            boolean flag = contains(list, username);
            if (!flag) {
                System.out.println("用户名未注册，请先注册");
                break;
            } else {
                if (captcha1.equals(captcha2)) {
                    if (checkUername_Password(list, username, password)) {
                        System.out.println("登录成功！");
                        break;
                    } else {
                        System.out.println("用户名和密码输入错误！");
                    }
                } else {
                    System.out.println("验证码不正确！");
                }
            }
        }
    }

关于这段代码：

if (!flag) {
System.out.println("用户名未注册，请先注册");
break;
}

取反说明flag为假时执行if后面的语句。

由于嵌套的比较深，进行修改：

可以看到减少了else语句的存在。

4、修改密码

（1）键盘录入用户名，判断当前用户名是否存在，如不存在，直接结束方法，并提示：未注册

（2）键盘录入身份证号码和手机号码

（3）判断当前用户的身份证号码和手机号码是否一致，

如果一致，则提示输入密码，进行修改。

如果不一致，则提示：账号信息不匹配，修改失败。

思路如下：

1、首先判断用户是否存在；

2、然后判断身份证号和手机号是否正确；

3、如果正确则修改密码。

    //忘记密码
    public static void forgetPassword(ArrayList<User> list) {
        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        //获取输入的用户名
        System.out.println("请输入用户名：");
        String username = sc.next();
        boolean flag = contains(list, username);
        if (!flag) {
            System.out.println("请先注册！");
            return;
        } else {
            //获取输入的身份证号
            System.out.println("请输入身份证号：");
            String ID = sc.next();
            //获取输入的手机号
            System.out.println("请输入手机号：");
            String phoneNumber = sc.next();
            //获取当前用户对象
            int index = getIndex(list, username);
            User user = list.get(index);
            //当用户的身份证号和手机号一致时
            if ((ID.equals(user.getID())) && (phoneNumber.equals(user.getPhonenumber()))) {
                while (true) {
                    //获取输入的密码
                    System.out.println("请输入密码：");
                    String password1 = sc.next();
                    System.out.println("请再次输入密码：");
                    String password2 = sc.next();
                    //将输入的密码与用户对象进行绑定
                    if (password1.equals(password2)) {
                        user.setPassword(password1);
                        break;
                    } else {
                        System.out.println("两次输入的密码不一致！请重新输入");
                    }
                }
            } else {
                System.out.println("账号信息不匹配，修改失败！");
            }
        }

    }

这是应用反向考虑的思想修改后的代码：

二、增删改查

初始菜单

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

学生类

属性：id、姓名、年龄、家庭住址

分析：

1、创建一个mainOrder方法

2、键盘录入用户的选择

3、用switch语句进行判断

    //初始菜单
    public static void mainOrder(ArrayList<Student> list){
        System.out.println("-------------欢迎来到黑马学生管理系统----------------\n" +
                "1：添加学生\n" +
                "2：删除学生\n" +
                "3：修改学生\n" +
                "4：查询学生\n" +
                "5：退出");
        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        //获取输入的信息
        System.out.println("请输入您的选择:");
        int num = sc.nextInt();
        switch (num){
            case 1 -> add(list);
            case 2 -> remove(list);
            case 3 -> update(list);
            case 4 -> select(list);
            case 5 -> exit();
            default -> System.out.println("请输入1-5中的一个！");
        }
        //当操作完成后再次回到
        mainOrder(list);
    }

当操作完成之后再次希望再次回到操作，这里使用递归实现的，视频中是用while(true)循环实现的。

break和continue用法区别：

（1）break：跳出for或者while循环；

（2）continue：跳出第i次遍历，进行第i+1次遍历；

对于退出，有两种方法：

①使用System.exit(0);结束虚拟机的运行进行退出；

②跳出最外层循环：break loop;

break一般是跳出离得最近的循环，当有多层循环而我们想指定跳出某个循环时，可以给这个循环起一个别名，然后break 别名就可以跳出这个循环了。

代码如下：

    //初始菜单
    public static void mainOrder(ArrayList<Student> list){
        //给外层的while循环起一个别名loop
        loop:while (true) {
            System.out.println("-------------欢迎来到黑马学生管理系统----------------\n" +
                    "1：添加学生\n" +
                    "2：删除学生\n" +
                    "3：修改学生\n" +
                    "4：查询学生\n" +
                    "5：退出");
            //1.创建一个Scanner对象
            Scanner sc = new Scanner(System.in);
            //获取输入的信息
            System.out.println("请输入您的选择:");
            int num = sc.nextInt();
            switch (num){
                case 1 -> add(list);
                case 2 -> remove(list);
                case 3 -> update(list);
                case 4 -> select(list);
                case 5 -> {
                    System.out.println("已退出学生管理系统！");
                    //break loop指跳出while循环
                    //break loop;
                    System.exit(0);
                }
                default -> System.out.println("请输入1-5中的一个！");
            }
        }
    }

添加功能

键盘录入每一个学生信息并添加，需要满足以下要求：

id唯一

    //添加
    public static void add(ArrayList<Student> list) {

        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        while (true) {
            //获取输入的信息
            System.out.println("请输入id：");
            String id = sc.next();
            System.out.println("请输入姓名：");
            String name = sc.next();
            System.out.println("请输入年龄：");
            int age = sc.nextInt();
            System.out.println("请输入家庭住址：");
            String address = sc.next();
            //将输入的信息与学生对象进行绑定
            Student student = new Student();
            student.setId(id);
            student.setName(name);
            student.setAge(age);
            student.setAddress(address);
            //将此对象的id与集合中所有对象的id进行判断
            boolean flag = contains(list, id);
            if (flag) {
                System.out.println("此id已存在！，请重新输入id");
            } else {
                list.add(student);
                System.out.println("添加成功！");
                break;
            }

        }
    }

查询功能

打印所有的学生信息，需要满足以下要求

如果没有学生信息，提示：当前无学生信息，请添加后再查询
如果有学生信息，需要按照以下格式输出。（不用过于纠结对齐的问题）

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

删除功能

键盘录入要删除的学生id，需要满足以下要求：

id存在删除
id不存在，需要提示不存在，并回到初始菜单

    //删除
    public static void remove(ArrayList<Student> list) {
        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        while (true) {
            //获取输入的信息
            System.out.println("请输入id：");
            String id1 = sc.next();
            //是否包含
            boolean flag = contains(list, id1);
            if (flag) {
                int index = getIndex(list,id1);
                list.remove(index);
                System.out.println("删除成功！");
                break;
            }
            else {
                System.out.println("此id不存在！，请重新输入id");
            }
        }
    }

修改功能

键盘录入要修改的学生id，需要满足以下要求

id存在，继续录入其他信息
id不存在，需要提示不存在，并回到初始菜单

    //修改
    public static void update(ArrayList<Student> list){
        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        String id1 = null;
        String id2 = null;
        while (true) {
            //获取输入的信息
            System.out.println("请输入要修改学生的id：");
            id1 = sc.next();
            System.out.println("请输入修改后学生的id：");
            id2 = sc.next();
            if(!id1.equals(id2)){
                break;
            } else {
                System.out.println("修改后的id与修改之前的重复，请重新输入！");
            }
        }
        //是否包含
        boolean flag = contains(list, id1);
        if (flag) {
            int index = getIndex(list,id1);
            Student student = list.get(index);
            student.setId(id2);
            System.out.println("修改成功！");
        }
        else {
            System.out.println("此id不存在！，请重新输入id");
        }
    }

这是完整的登录代码：

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


public class test03 {
    public static void main(String[] args) {
        ArrayList<User> list = new ArrayList<>();
        welcome(list);

    }

    //欢迎页面
    public static void welcome(ArrayList<User> list) {
        while (true) {
            System.out.println("欢迎来到学生管理系统");
            System.out.println("请选择操作:1登录 2注册 3忘记密码");
            //1.创建一个Scanner对象
            Scanner sc = new Scanner(System.in);
            //获取输入的信息
            System.out.println("请输入操作：");
            String operation = sc.next();
            switch (operation) {
                case "1" -> login(list);
                case "2" -> register(list);
                case "3" -> forgetPassword(list);
                default -> System.out.println("请输入1-3数字中的一个！");
            }
        }
    }

    //注册
    public static void register(ArrayList<User> list) {
        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        User user = new User();
        while (true) {
            //获取输入的用户名
            System.out.println("请输入用户名：");
            String username = sc.next();

            //首先验证用户名的格式
            if (checkUsername(list, username)) {
                //满足条件时进行用户唯一性的判断
                if (!contains(list, username)) {
                    //将输入的用户名与用户对象进行绑定
                    user.setUsername(username);
                    break;
                } else {
                    System.out.println("输入的用户名已存在！");
                }
            } else {
                System.out.println("用户名不合法！请重新输入");
            }
        }
        while (true) {
            //获取输入的密码
            System.out.println("请输入密码：");
            String password1 = sc.next();
            System.out.println("请再次输入密码：");
            String password2 = sc.next();
            //将输入的密码与用户对象进行绑定
            if (password1.equals(password2)) {
                user.setPassword(password1);
                break;
            } else {
                System.out.println("两次输入的密码不一致！请重新输入");
            }
        }
        while (true) {
            //获取输入的身份证号
            System.out.println("请输入身份证号：");
            String ID = sc.next();
            //将输入的密码与用户对象进行绑定
            if (checkID(ID)) {
                user.setID(ID);
                break;
            } else {
                System.out.println("输入的身份证号不合法！请重新输入");
            }
        }
        while (true) {
            //获取输入的手机号
            System.out.println("请输入手机号：");
            String phoneNumber = sc.next();
            //将输入的密码与用户对象进行绑定
            if (checkPhoneNumber(phoneNumber)) {
                user.setPhonenumber(phoneNumber);
                break;
            } else {
                System.out.println("输入的手机号不合法！请重新输入");
            }
        }
        list.add(user);
        System.out.println("添加成功！");

    }

    //登录
    public static void login(ArrayList<User> list) {
        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {

            //获取输入的信息
            //输入可以从用户名开始
            //这里我希望在信息输入完成之后再进行判断
            System.out.println("请输入用户名：");
            String username = sc.next();
            System.out.println("请输入密码：");
            String password = sc.next();
            //生成验证码
            String captcha1 = createCaptcha();
            System.out.println("生成的验证码为：" + captcha1);
            System.out.println("请输入验证码：");
            String captcha2 = sc.next();

            // 先验证验证码，再进行用户名和密码的判断
            // 1、验证码只给一次的验证机会
            if (!(captcha1.equalsIgnoreCase(captcha2))){
                System.out.println("验证码不正确！");
                continue;
            }
            //走到这里说明没有结束这次循环，也就是验证码验证正确
            //2、然后将此对象的username与集合中所有对象的username进行判断
            boolean flag = contains(list, username);
            // 不存在
            if (!flag) {
                System.out.println("用户名未注册，请先注册");
                break;
            }
            // 走到这一步说明用户名存在
            // 将username和password封装到对象中进行传递
            User user = new User(username, password, null, null);
            // 检查用户名和密码是否正确
            if (checkUserInfo(list, user)) {
                System.out.println("登录成功！");
                Test02.studentSystem();
                break;
            } else {
                System.out.println("用户名和密码输入错误！");
            }
        }
    }

    //忘记密码
    public static void forgetPassword(ArrayList<User> list) {
        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        //获取输入的用户名
        System.out.println("请输入用户名：");
        String username = sc.next();
        boolean flag = contains(list, username);
        if (!flag) {
            System.out.println("请先注册！");
            return;
        }
        //获取输入的身份证号
        System.out.println("请输入身份证号：");
        String ID = sc.next();
        //获取输入的手机号
        System.out.println("请输入手机号：");
        String phoneNumber = sc.next();
        //获取当前用户对象
        int index = getIndex(list, username);
        User user = list.get(index);
        //当用户的身份证号和手机号不一致时
        if (!((ID.equals(user.getID())) && (phoneNumber.equals(user.getPhonenumber())))) {
            System.out.println("账号信息不匹配，修改失败！");
            //通过return结束方法
            return;
        }
        //走到这一步说明用户的身份证号和手机号一致
        while (true) {
            //获取输入的密码
            System.out.println("请输入新的密码：");
            String password1 = sc.next();
            System.out.println("请再次输入密码：");
            String password2 = sc.next();
            //将输入的密码与用户对象进行绑定
            if (password1.equals(password2)) {
                user.setPassword(password1);
                break;
            } else {
                System.out.println("两次输入的密码不一致！请重新输入");
            }
        }
    }


    //根据username判断此用户是否存在
    public static boolean contains(ArrayList<User> list, String username) {
        return getIndex(list, username) >= 0;
    }

    //返回id的索引
    public static int getIndex(ArrayList<User> list, String username) {
        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            if (username.equals(user.getUsername())) {
                return i;
            }
        }
        return -1;
    }

    //判断用户名是否合法
    public static boolean checkUsername(ArrayList<User> list, String username) {
        int length = username.length();
        if ((3 > length) || (length > 15)) {
            return false;
        }
        if (!check31(username)) {
            return false;
        }
        if (!check32(username)) {
            return false;
        }
        return true;
    }

    //检查是否是数字和字母的组合
    public static boolean check31(String username) {
        for (int i = 0; i < username.length(); i++) {
            //依次获取每一个字符
            char c = username.charAt(i);
            //((c >= 'a') && (c <= 'z'))表示c是字符a-z之间的一个
            if (!(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) || ((c >= '0') && (c <= '9')))) {
                return false;
            }
        }
        return true;
    }

    //判断是否有大小写字母存在
    public static boolean check32(String username) {
        for (int i = 0; i < username.length(); i++) {
            char c = username.charAt(i);
            if ((((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')))) {
                return true;
            }
        }
        return false;
    }

    public static boolean checkID(String ID) {
        //获取ID的长度
        int length = ID.length();
        //判断长度是否为18
        if (length == 18) {
            //判断开头是否为0
            if (ID.charAt(0) != '0') {
                //获取最后一位
                char c1 = ID.charAt(length - 1);
                if (((c1 > '0') && (c1 < '9')) || (c1 == 'X') || (c1 == 'x')) {
                    //循环遍历前17位
                    for (int i = 0; i < length - 1; i++) {
                        char c2 = ID.charAt(i);
                        if ((c2 > '0') && (c2 < '9')) {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }

    public static boolean checkPhoneNumber(String phoneNumber) {
        //获取手机号的长度
        int length = phoneNumber.length();
        //判断长度是否为11
        if (length == 11) {
            //判断开头是否为0
            if (phoneNumber.charAt(0) != '0') {
                //循环遍历前11位
                for (int i = 0; i < length; i++) {
                    char c2 = phoneNumber.charAt(i);
                    if ((c2 > '0') && (c2 < '9')) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    // 生成验证码
    public static String createCaptcha() {
        //创建一个sb对象用来存52个大小写英文字母
        StringBuilder sb1 = new StringBuilder();
        for (int i = 0; i < 26; i++) {
            char c1 = (char) ('a' + i);
            sb1.append(c1);
            char c2 = (char) ('A' + i);
            sb1.append(c2);
        }
        String string = sb1.toString();
        //创建一个sb对象用来存字符串
        StringBuilder sb2 = new StringBuilder();
        //随机选择数组中的字母，循环4次生成4个
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            int index = r.nextInt(string.length());
            sb2.append(string.charAt(index));
        }
        //生成数字
        int number = r.nextInt(10);
        //生成数字插入的位置
        int position = r.nextInt(5);
        sb2.insert(position, number);
        String captcha = sb2.toString();
        return captcha;
    }

    //判断用户名和密码是否正确
    public static boolean checkUserInfo(ArrayList<User> list, User user1) {
        String username = user1.getUsername();
        String password = user1.getPassword();
        for (int i = 0; i < list.size(); i++) {
            User user2 = list.get(i);
            if ((username.equals(user2.getUsername())) && (password.equals(user2.getPassword()))) {
                return true;
            }
        }
        return false;
    }
}

这是完整的增删改查代码：

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

public class Test02 {
    public static void studentSystem() {
        //创建一个容器
        ArrayList<Student> list = new ArrayList<>();
        mainOrder(list);
    }
    //当这些操作成功的时候希望可以给出提示

    //添加
    public static void add(ArrayList<Student> list) {

        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        while (true) {
            //获取输入的信息
            System.out.println("请输入id：");
            String id = sc.next();
            System.out.println("请输入姓名：");
            String name = sc.next();
            System.out.println("请输入年龄：");
            int age = sc.nextInt();
            System.out.println("请输入家庭住址：");
            String address = sc.next();
            //将输入的信息与学生对象进行绑定
            Student student = new Student();
            student.setId(id);
            student.setName(name);
            student.setAge(age);
            student.setAddress(address);
            //将此对象的id与集合中所有对象的id进行判断
            boolean flag = contains(list, id);
            if (flag) {
                System.out.println("此id已存在！，请重新输入id");
            } else {
                list.add(student);
                System.out.println("添加成功！");
                break;
            }

        }
    }


    //删除
    public static void remove(ArrayList<Student> list) {
        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        while (true) {
            //获取输入的信息
            System.out.println("请输入id：");
            String id1 = sc.next();
            //是否包含
            boolean flag = contains(list, id1);
            if (flag) {
                int index = getIndex(list,id1);
                list.remove(index);
                System.out.println("删除成功！");
                break;
            }
            else {
                System.out.println("此id不存在！，请重新输入id");
            }
        }
    }

    //修改
    public static void update(ArrayList<Student> list){
        //1.创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        String id1 = null;
        String id2 = null;
        while (true) {
            //获取输入的信息
            System.out.println("请输入要修改学生的id：");
            id1 = sc.next();
            System.out.println("请输入修改后学生的id：");
            id2 = sc.next();
            if(!id1.equals(id2)){
                break;
            } else {
                System.out.println("修改后的id与修改之前的重复，请重新输入！");
            }
        }
        //是否包含
        boolean flag = contains(list, id1);
        if (flag) {
            int index = getIndex(list,id1);
            Student student = list.get(index);
            student.setId(id2);
            System.out.println("修改成功！");
        }
        else {
            System.out.println("此id不存在！，请重新输入id");
        }
    }

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

    //根据id判断容器是否包含
    public static boolean contains(ArrayList<Student> list, String id) {
        return getIndex(list,id) >= 0;
    }
    //返回id的索引
    public static int getIndex(ArrayList<Student> list, String id) {
        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            if (id.equals(s.getId())) {
                return i;
            }
        }
        return -1;
    }
    //初始菜单
    public static void mainOrder(ArrayList<Student> list){
        //给外层的while循环起一个别名loop
        loop:while (true) {
            System.out.println("-------------欢迎来到黑马学生管理系统----------------\n" +
                    "1：添加学生\n" +
                    "2：删除学生\n" +
                    "3：修改学生\n" +
                    "4：查询学生\n" +
                    "5：退出");
            //1.创建一个Scanner对象
            Scanner sc = new Scanner(System.in);
            //获取输入的信息
            System.out.println("请输入您的选择:");
            int num = sc.nextInt();
            switch (num){
                case 1 -> add(list);
                case 2 -> remove(list);
                case 3 -> update(list);
                case 4 -> select(list);
                case 5 -> {
                    System.out.println("已退出学生管理系统！");
                    //break loop指跳出while循环
                    //break loop;
                    System.exit(0);
                }
                default -> System.out.println("请输入1-5中的一个！");
            }
        }
    }
}

经过上述功能的实现，有一点感悟：

1、首先是数据的永久化存储是放到数据库中的，例如MySQL；

2、取出数据库中的数据之后要封装到对象中，这就用到了之后的框架，例如Mybatis。