人生第一个项目(学生管理系统)(进阶版)

题目:

package Project.Student_system_upper版;

public class 题目学生股那里系统upper {
    //增删改查可以直接参照之前的文件代码(cv大法)
    /* 为学生管理系统写一个登录,注册,忘记密码的功能
       只有用户登陆成功之后,才能进入到学生管理系统中进行相应操作*/

    /*分析:
          1. 登陆界面
          需要有以下内容:
              欢迎来到学生管理系统
              其选择操作:1. 登录     2. 注册     3. 忘记密码

          2. 用户类:
                   属性: 1. 用户名   2. 密码   3. 身份证号码    4. 手机号码

          注册功能:
                1.  用户名满足以下要求:
                    验证要求:
                        (1)用户名唯一
                        (2)用户名长度必须在3~15位之间
                        (3)只能是字母和数字的组合,但是不能是纯数字

                2.  密码键盘要输入两次,两次一直才可以进行注册

                3.  身份证号码需要验证:
                    验证要求:
                            (1)长度为18位
                            (2)不能以0开头
                            (3)前17位,必须都是数字

                4.   手机号验证:
                     验证要求:
                            (1)长度为11位
                            (2)不能以0开头
                            (3)必须都是数字

           登录功能:
                 1. 键盘录入用户名
                 2. 键盘录入密码
                 3. 键盘录入验证码
                 验证要求:
                        (1)用户名如果未注册,直接结束方法,并提示:用户名未注册,请先注册
                        (2)判断验证码是否正确,如不正确,重新读入
                        (3)再判断用户名和密码是否正确,有3次机会

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

            验证码规则:
                    1. 长度为5
                    2. 由4位大写或者小写字母和1位数字组成,同一个字母可以重复
                    3. 数字可以出现在任意位置
     */
}

思路:

package Project.Student_system_upper版;

public class 思路 {
    //增删改查,cv前面的代码

    //思路:
    //      1.写用户类
    //      2.用方法读出登陆界面
    //      3.用方法读取用户在登陆界面所输入的选项

    //注册功能:
    //      4.写方法,传入的参数为用户集合

    //      5.先读入一个用户名
    //      6.判断用户名长度是否在3~15位之间 (不是提示:用户名不符合规范)
    //      7.判断用户名是否全是数字         (是提示:用户名不符合规范)
    //      8.判断用户名是否唯一             (不是提示:用户名重复)

    //      (写方法)无参数,返回布尔值
    //      9.第一次 读入密码(无要求不现实:个人添加要求:长度为10位以下)
    //      10.第二次 读入密码
    //      11.判断这两次密码是否一致

    //      (写方法)无参数,返回字符串
    //      12.读入身份证号码
    //      13.判断长度是否为18      (不是提示:身份证号码不符合规范)
    //      14.判断前17位是否都为数字 (不是提示:身份证号码不符合规范)
    //      15.判断第1位是否为0       (是提示:身份证号码不符合规范)

    //      (写方法)无参数,返回字符串
    //      16.读入手机号
    //      17.判断长度是否为11        (不是提示:手机号码不符合规范)
    //      18.判断是否都是数字         (不是提示:手机号码不符合规范)
    //      19.判断是否以0开头        (是提示:手机号码不符合规范)


    //登录功能:
    //      (写方法)传入用户集合
    //      1.录入用户名
    //      2.用户名如果未注册,直接结束方法,并提示:用户名未注册,请先注册
    //      3.录入密码
    //
            //      (写方法)生成一个验证码
            //      1.长度为5
            //      2.由4位大写或者小写字母和1位数字组成,同一个字母可以重复
            //      3.数字可以出现在任意位置

    //      4.判断验证码是否正确,如不正确,重新读入

    //      (写方法)传入用户集合,用户名,密码,无返回
    //      5.判断用户名和密码是否正确,有3次机会
    //
    //
    //
    //忘记密码:
    //       (写方法)传入用户集合
    //       1. 键盘录入用户名,判断当前用户名是否存在,如果不存在直接结束方法,并提示:未注册
                    //       2. 键盘录入身份证号码和手机号码
                    //       3. 判断当前用户的身份证号和手机号码是否一致
                    //         (1)如果一致,则提示输入密码,进行修改
                    //         (2)如果不一致,则提示:账号信息不匹配,修改失败

    //增删改查
}

开始建类:

package Project.Student_system_upper版;

public class User_Object {
    private String User_name;           //用户名
    private String Pass_word;           //密码
    private String ID_Number;           //身份证号码
    private String Phone_number;        //手机号码

    public User_Object() {
    }

    public User_Object(String User_name, String Pass_word, String ID_Number, String Phone_number) {
        this.User_name = User_name;
        this.Pass_word = Pass_word;
        this.ID_Number = ID_Number;
        this.Phone_number = Phone_number;
    }

    /**
     * 获取
     * @return User_name
     */
    public String getUser_name() {
        return User_name;
    }

    /**
     * 设置
     * @param User_name
     */
    public void setUser_name(String User_name) {
        this.User_name = User_name;
    }

    /**
     * 获取
     * @return Pass_word
     */
    public String getPass_word() {
        return Pass_word;
    }

    /**
     * 设置
     * @param Pass_word
     */
    public void setPass_word(String Pass_word) {
        this.Pass_word = Pass_word;
    }

    /**
     * 获取
     * @return ID_Number
     */
    public String getID_Number() {
        return ID_Number;
    }

    /**
     * 设置
     * @param ID_Number
     */
    public void setID_Number(String ID_Number) {
        this.ID_Number = ID_Number;
    }

    /**
     * 获取
     * @return Phone_number
     */
    public String getPhone_number() {
        return Phone_number;
    }

    /**
     * 设置
     * @param Phone_number
     */
    public void setPhone_number(String Phone_number) {
        this.Phone_number = Phone_number;
    }

    public String toString() {
        return "User_Object{User_name = " + User_name + ", Pass_word = " + Pass_word + ", ID_Number = " + ID_Number + ", Phone_number = " + Phone_number + "}";
    }
}

开始主类:

package Project.Student_system_upper版;

import Project.Student_system.Student_Object;

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

public class Main {
    public static void main(String[] args) {
        ArrayList<User_Object> Tuple_User = new ArrayList<>();

        int number = Login_Interface();//获得登陆界面选项和打印登陆界面

        while (true) {
            if (number == 1) {
                if (Login(Tuple_User)) {
                    ArrayList<Student_Object> Tuple_Student = new ArrayList<>();
                    Initial_Menu();
                    while (true) {
                        int User_Number = Get_User_Number();
                        if (User_Number == 1) {
                            ADD_Student(Tuple_Student);
                            System.out.println("还有需要请读入数字:");
                        }
                        else if (User_Number == 2) {
                            Delete_Student(Tuple_Student);
                        }
                        else if (User_Number == 3) {
                            Modify_Student(Tuple_Student);
                            System.out.println("还有需要请读入数字:");
                        } else if (User_Number == 4) {
                            Find_Student(Tuple_Student);
                            System.out.println("还有需要请读入数字:");
                        } else if (User_Number == 5) {
                            System.out.println("退出程序中...");
                            System.exit(0); //停止虚拟机运行
                        } else if (User_Number == 6) {
                            Print_all_data(Tuple_Student);
                        }
                    }
                }

                number = Login_Interface();
            } else if (number == 3) {
                Forgot_Password(Tuple_User);

                number = Login_Interface();
            } else if (number == 2) {
                Register_Account(Tuple_User);

                number = Login_Interface();
            }
            else if(number == 4){
                System.out.println("程序退出中...");
                System.exit(0);
            }
        }
    }


//


    //登录界面
    //登陆界面(返回用户在登陆界面的选项) 无参数
    public static int Login_Interface() {
        System.out.println("欢迎来到学生管理系统\n" + "其选择操作:1. 登录     2. 注册     3. 忘记密码");
        System.out.print("请读入您的选项:");
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt();
        return number;
    }

    //登录功能(登入成功返回true,失败返回false)参数为用户集合
    public static boolean Login(ArrayList<User_Object> Tuple_User) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.print("请输入用户名:");
            String User_name = sc.next();
            for (int i = 0; i < 3; i++) {
                if (User_name_judement(Tuple_User, User_name)) {
                    System.out.print("请输入密码:");
                    String Pass_word = sc.next();
                    String CAPTCHA = CAPTCHA(); //获取验证码
                    if (CAPTCHA_judgment(CAPTCHA)) {
                        if (Judgement_username_and_password(Tuple_User, User_name, Pass_word)) {
                            System.out.println("登入成功");
                            return true;
                        } else {
                            System.out.println("密码错误!请重新读入:");
                            System.out.println("您还有" + (2 - i) + "次机会写入密码");
                            if (i == 2) {
                                System.out.println("账户锁定!");
                                return false;
                            }
                        }
                    }
                } else {
                    System.out.println("用户名未注册,请先注册!");
                    return false;
                }
            }
        }
    }

    //判断密码是否正确(这里其实有问题,我在判断用户名存在问题上就已经解决了用户名是否正确,所以这里只需要判断密码是否正确就ok)正确返回ture,错误返回false
    public static boolean Judgement_username_and_password(ArrayList<User_Object> Tuple_User, String User_name, String Pass_word) {
        for (int i = 0; i < Tuple_User.size(); i++) {
            if (Tuple_User.get(i).getUser_name().equals(User_name)) {
                if (Tuple_User.get(i).getPass_word().equals(Pass_word)) {
                    return true;
                }
            }
        }
        return false;
    }

    //用户名判断(存在返回true,不存在返回false) 参数为:用户集合,用户名
    public static boolean User_name_judement(ArrayList<User_Object> Tuple_User, String User_name) {
        for (int i = 0; i < Tuple_User.size(); i++) {
            if (Tuple_User.get(i).getUser_name().equals(User_name)) {
                return true;
            }
        }
        return false;
    }

    //验证码判断(写对了返回ture,错了返回false)参数为验证码
    public static boolean CAPTCHA_judgment(String CAPTCHA) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("验证码为:" + CAPTCHA);
            System.out.print("请输入验证码");
            String User_CAPTCHA = sc.next();
            if (User_CAPTCHA.equals(CAPTCHA)) {
                return true;
            } else {
                System.out.println("验证码错误,请重新读入验证码!");
                CAPTCHA = CAPTCHA();
            }
        }
    }

    //生成验证码(无参数)
    public static String CAPTCHA() {
        char Result[] = new char[5];
        char alphabet[] = new char[52];
        char Number[] = new char[10];
        char sign = 'A';
        int i = 0;
        while (sign <= 'Z') {
            alphabet[i++] = sign++;
        }
        sign = 'a';
        while (sign <= 'z') {
            alphabet[i++] = sign++;
        }

        char number_sign = '0';
        int j = 0;
        while (number_sign <= '9') {
            Number[j++] = number_sign++;
        }

//        for (i = 0; i < alphabet.length; i++) {
//            System.out.print(alphabet[i]);
//        }
//        System.out.println("\n");
//        for (i = 0; i < Number.length; i++) {
//            System.out.print(Number[i]);
//        }
        Random r = new Random();
        int random_number_index_in_Result = r.nextInt(Result.length);
        int number_index = r.nextInt(Number.length);

        char number_char = Number[number_index];
        Result[random_number_index_in_Result] = number_char;

        for (i = 0; i < Result.length; i++) {
            if (Result[i] == '\0') {
                int random_index = r.nextInt(alphabet.length);
                char Alphabet = alphabet[random_index];
                Result[i] = Alphabet;
            }
        }

        String result_string = new String(Result);
        return result_string;
    }





//忘记密码

    //忘记密码
    public static void Forgot_Password(ArrayList<User_Object> Tuple_User) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请写入您想寻找的用户名:");
        String User_name = sc.next();
        if (User_name_judement(Tuple_User, User_name)) {
            System.out.println("请写入您的ID:");
            String ID = sc.next();
            System.out.println("请输入您的手机号码:");
            String Phone = sc.next();
            if (Judgment_Mobile_ID_Number(Tuple_User, User_name, ID, Phone)) {
                Change_Password(Tuple_User, User_name);
            }
        } else {
            System.out.println("未注册");
            System.exit(0);
        }
    }

    //判断身份证号和手机号是否一致(传入用户集合,用户名,身份证号码,手机号码) 是返回true,否返回false
    public static boolean Judgment_Mobile_ID_Number(ArrayList<User_Object> Tuple_User, String User_name, String ID, String Phone) {

        for (int i = 0; i < Tuple_User.size(); i++) {
            if (Tuple_User.get(i).getUser_name().equals(User_name)) {
                if (Tuple_User.get(i).getID_Number().equals(ID) && Tuple_User.get(i).getPhone_number().equals(Phone)) {
                    return true;
                } else {
                    System.out.println("身份证号码或者手机号码错误!");
                    return false;
                }
            }
        }
        return false;
    }

    //修改密码(传入用户集合,用户名) 修改结束提示:修改完成
    public static void Change_Password(ArrayList<User_Object> Tuple_User, String User_name) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请修改您的密码:");
            String number = sc.next();
            if (Pass_Word(number)) {
                for (int i = 0; i < Tuple_User.size(); i++) {
                    if (Tuple_User.get(i).getUser_name().equals(User_name)) {
                        Tuple_User.get(i).setPass_word(number);
                        System.out.println("修改完毕");
                        return;
                    }
                }
            } else {
                System.out.println("您的密码格式不符合规格,请重新输入!");
            }
        }
    }

    //判断密码是否符合规格并返回密码,无参数
    public static String Pass_Word() {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入密码:");
            String pass_word = sc.next();
            if (pass_word.length() <= 10) {
                System.out.println("请再次输入密码:");
                String pass = sc.next();
                if (pass.equals(pass_word)) {
                    return pass;
                }
            } else {
                System.out.println("密码不符合规格,请重新输入:");
            }
        }
    }

    //判断密码是否符合规格
    public static boolean Pass_Word(String pass_word) {
        if (pass_word.length() <= 10 && pass_word.length() >= 1) {
            return true;
        } else {
            return false;
        }
    }


///


    //注册账户


    //注册账户
    public static void Register_Account(ArrayList<User_Object> Tuple_User) {
        String U_N = Get_Name();
        String Correct_U_N = Get_Correctly_UN(Tuple_User, U_N);

        String Correct_P_W = Get_password();

        String ID = Get_ID();
        String Correct_ID = Get_ID(ID);

        String Phone_number = Phone_N();
        String Correct_P_N = Get_Phone(Phone_number);

        User_Object user = new User_Object(Correct_U_N, Correct_P_W, Correct_ID, Correct_P_N);
        Tuple_User.add(user);
        System.out.println("存入完毕");
    }

    //判断用户名长度是否符合(传入参数:用户名)正确返回true,错误返回false
    public static boolean Judgment_Username_Length(String User_name) {
        if (User_name.length() >= 3 && User_name.length() <= 15) {
            return true;
        }
        return false;
    }

    //判断用户名是否全都是数字(传入参数:用户名)正确返回true,错误返回false
    public static boolean Judgment_Username_NOT_All_Number(String User_name) {
        //思路: 1. 可以用一个计数器,记录出现了多少个数字,如果总个数==字符串长度,则返回false
        //      2. 或者只要出现了一个不是数字样式的,就返回ture
        char char_User_name[] = User_name.toCharArray();
        for (int i = 0; i < char_User_name.length; i++) {
            if (char_User_name[i] < '0' && char_User_name[i] > '9') {
                return false;
            }
        }
        return true;
    }

    //判断用户名是否唯一(传入参数:用户集合,用户名)唯一返回true,不唯一返回false
    public static boolean Judgment_Username_Unique(ArrayList<User_Object> Tuple_User, String User_name) {
        //思路:1.计数器思想
        //    2. 先找到第一次出现此用户名的集合索引,从这个索引往后找,如果还出现就返回false,没出现就返回true

        for (int i = 0; i < Tuple_User.size(); i++) {
            if (Tuple_User.get(i).getUser_name().equals(User_name)) {
                for (int j = i; j < Tuple_User.size(); j++) {
                    j++;
                    if (Tuple_User.get(j).getUser_name().equals(User_name)) {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    //用户读入用户名(空参) 返回用户名
    public static String Get_Name() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的用户名:");
        String U_N = sc.next();
        return U_N;
    }

    //(正确)获得用户名(参数:用户集合,用户名)正确返回
    public static String Get_Correctly_UN(ArrayList<User_Object> Tuple_User, String User_name) {
        if (Judgment_Username_Length(User_name)) {
            if (Judgment_Username_NOT_All_Number(User_name)) {
                if (Judgment_Username_Unique(Tuple_User, User_name)) {
                    return User_name;
                } else {
                    System.out.println("用户名重复");
                    System.exit(0);
                }
            } else {
                System.out.println("用户名不符合规范(数字)");
                System.exit(0);
            }
        } else {
            System.out.println("用户名不符合规范(长度)");
            System.exit(0);
        }
        return "用户名错误";
    }


//注册判断密码

    //用户读入密码
    public static String Get_password() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入密码:");
        String password = sc.next();
        System.out.println("请再次读入密码:");
        String pd = sc.next();
        if (pd.equals(password) && Register_Judgement_Password(password)) {
            return password;
        }
        else{
            System.out.println("密码不同或者长度超过!");
            System.exit(0);
        }
        return "密码错误";
    }

    //注册判断密码(修改密码的方法返回参数,这里需要再写一个方法)参数:用户密码. 符合规范返回true,不符合返回false
    public static boolean Register_Judgement_Password(String U_PW) {
        if (U_PW.length() <= 10) {
            return true;
        }
        return false;
    }


//注册判断身份证号码

    //用户读入身份证号码(无参数)返回用户读入的身份证号码
    public static String Get_ID() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入身份证号码:");
        String ID = sc.next();
        return ID;
    }

    //判断长度是否为18(参数为身份证号码) 是18返回true,否返回false
    public static boolean Length_18(String ID) {
        if (ID.length() == 18) {
            return true;
        }
        System.out.println("身份证号码不符合规范");
        return false;
    }

    //判断前17位是否都为数字(参数为身份证号码) 是返回true,否返回false
    public static boolean ID_17_ISnumber(String ID) {
        //思路: 前17位出现了一个不是数字就返回false
        char[] ID_char = ID.toCharArray();
        for (int i = 0; i < ID_char.length - 1; i++) {
            if (ID_char[i] < '0' || ID_char[i] > '9') {
                System.out.println("身份证号码不符合规范");
                return false;
            }
        }
        return true;
    }

    //判断第1位是否为0(参数为身份证号码) 是返回true,否返回false
    public static boolean ID_First_IS0(String ID) {
        char[] ID_char = ID.toCharArray();
        if (ID_char[0] == '0') {
            System.out.println("身份证号码不符合规范");
            return true;
        }
        return false;
    }

    //返回正确的身份号码
    public static String Get_ID(String ID) {
        if (Length_18(ID) && ID_17_ISnumber(ID)) {
            if (!ID_First_IS0(ID)) {
                return ID;
            }
        }
        else{
            System.out.println("ID错误");
            System.exit(0);
        }
        return "ID错误";
    }


//注册判断手机号

    //用户读入手机号(无参数) 返回手机号
    public static String Phone_N() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号:");
        String NB = sc.next();
        return NB;
    }

    //判断长度是否为11(参数:手机号) 是返回true,否返回false
    public static boolean NB_Length_IS11(String Phone) {
        if (Phone.length() == 11) {
            return true;
        }
        System.out.println("手机号码不符合规范");
        return false;
    }

    //判断是否都是数字(参数:手机号) 是返回true,否返回false
    public static boolean ALL_NB(String Phone) {
        char[] NB = Phone.toCharArray();
        for (int i = 0; i < NB.length; i++) {
            if (NB[i] < '0' || NB[i] > '9') {
                System.out.println("手机号码不符合规范");
                return false;
            }
        }
        return true;
    }

    //判断是否以0开头(参数:手机号) 是返回true,否返回false
    public static boolean Head_IS_0(String Phone) {
        char[] phone_char = Phone.toCharArray();
        if (phone_char[0] == '0') {
            System.out.println("身份证号码不符合规范");
            return true;
        }
        return false;
    }

    //返回正确的手机号
    public static String Get_Phone(String Phone) {
        if (NB_Length_IS11(Phone) && ALL_NB(Phone)) {
            if (!Head_IS_0(Phone)) {
                return Phone;
            }
        }
        System.out.println("手机号错误");
        System.exit(0);
        return "手机号错误";
    }





    //打印初始菜单
    public static void Initial_Menu() {
        System.out.println("-----------------欢迎来到学生管理系统------------------\n" +
                "1: 添加学生\n" +
                "2: 删除学生\n" +
                "3: 修改学生\n" +
                "4: 查询学生\n" +
                "5: 退出\n" +
                "请输入您的选择:"
        );
    }


    //读入用户所传入选项
    public static int Get_User_Number() {
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt();
        return number;
    }


    //添加学生功能实现
    public static void ADD_Student(ArrayList<Student_Object> Tuple_Student) {
        Scanner sc = new Scanner(System.in);

        while (true) {
            //读入学生ID(string类型)
            System.out.println("读入要添加的学生的ID:");
            String ID = sc.next();
            //读入学生姓名
            System.out.println("读入要添加的学生的Name:");
            String Name = sc.next();
            //读入学生年龄
            System.out.println("读入要添加的学生的Age:");
            int Age = sc.nextInt();
            //读入学生住址:
            System.out.println("读入要添加的学生的住址:");
            String Home_address = sc.next();

            //用户读入学生信息
            Student_Object Student = new Student_Object(ID, Name, Age, Home_address);

            int sign = 0;
            //存入学生数据(要判断ID是否唯一)
            for (int i = 0; i < Tuple_Student.size(); i++) {
                if (Tuple_Student.get(i).getID().equals(Student.getID())) {
                    System.out.println("有重复ID,不得添加!,请重新读入:");
                    sign = 1;
                }
            }
            if (sign == 0) {
                Tuple_Student.add(Student);
                System.out.println("添加成功!");
                return;
            }
        }
    }


    //删除学生功能实现
    public static void Delete_Student(ArrayList<Student_Object> Tuple_Student) {
        Scanner sc = new Scanner(System.in);
        //存入用户想删除的学生的ID
        System.out.println("请读入您想删除的学生的ID:");
        String Delete_ID = sc.next();
        //判断是否存在此ID
        for (int i = 0; i < Tuple_Student.size(); i++) {
            if (Tuple_Student.get(i).getID().equals(Delete_ID)) {
                Tuple_Student.remove(i);//删除此学生对象
                System.out.println("删除成功");
                System.out.println("还有需要请读入数字:");
                return;
            }
        }
        System.out.println("无此学生ID");
        Initial_Menu();
    }


    //修改学生功能实现
    public static void Modify_Student(ArrayList<Student_Object> Tuple_Student) {
        Scanner sc = new Scanner(System.in);
        //读入学生ID(string类型)
        System.out.println("读入要修改的学生的ID:");
        String ID = sc.next();
        //读入学生姓名
        System.out.println("读入要修改的学生的Name:");
        String Name = sc.next();
        //读入学生年龄
        System.out.println("读入要修改的学生的Age:");
        int Age = sc.nextInt();
        //读入学生住址:
        System.out.println("读入要修改的学生的住址:");
        String Home_address = sc.next();

        while (true) {
            //存入用户想修改的学生的ID
            System.out.println("请读入您想修改的学生的ID:");
            String Delete_ID = sc.next();

            //判断是否存在此ID
            for (int i = 0; i < Tuple_Student.size(); i++) {
                if (Tuple_Student.get(i).getID().equals(Delete_ID)) {
                    Tuple_Student.get(i).setAge(Age);
                    Tuple_Student.get(i).setID(ID);
                    Tuple_Student.get(i).setName(Name);
                    Tuple_Student.get(i).setHome_address(Home_address);
                    System.out.println("修改成功");
                    return;
                }
            }
            System.out.println("无此学生ID,请重新读入:");
        }
    }


    //查询功能实现
    public static void Find_Student(ArrayList<Student_Object> Tuple_Student) {
        Scanner sc = new Scanner(System.in);

        while (true) {
            //存入用户想删除的学生的ID
            System.out.println("请读入您想查询的学生的ID:");
            String Delete_ID = sc.next();

            //判断是否存在此ID
            for (int i = 0; i < Tuple_Student.size(); i++) {
                if (Tuple_Student.get(i).getID().equals(Delete_ID)) {
                    System.out.println("ID为: " + Tuple_Student.get(i).getID() + ".. 名字为: " + Tuple_Student.get(i).getName() + ".. 年龄为:" +
                            Tuple_Student.get(i).getAge() + ".. 住址为: " + Tuple_Student.get(i).getHome_address());
                    return;
                }
            }
            System.out.println("无此学生ID,请重新读入:");
        }
    }


    //打印全部数据
    public static void Print_all_data(ArrayList<Student_Object> Tuple_Student) {
        for (int i = 0; i < Tuple_Student.size(); i++) {
            System.out.println(
                    "ID         " + "姓名       " + "年龄      " + " 家庭住址");

            System.out.println(
                    Tuple_Student.get(i).getID() + "          " + Tuple_Student.get(i).getName() + "          " + Tuple_Student.get(i).getAge() + "          " + Tuple_Student.get(i).getHome_address()
            );
        }
    }
}