• Java学生管理系统升级版

    在前一个Java学生管理系统的基础上进行升级（Java学生管理系统）

    需求：

    为学生管理系统书写一个登陆、注册、忘记密码的功能。

    只有用户登录成功之后，才能进入到学生管理系统中进行增删改查操作。

    分析：

    登录界面：

    1. System.out.println("欢迎来到学生管理系统");
    2. 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

      实现代码：

    APP.java:

    1. import java.util.ArrayList;
    2. import java.util.Random;
    3. import java.util.Scanner;
    4.  
    5. public class APP {
    6.     public static void main(String[] args) {
    7.         ArrayList<User> list = new ArrayList<>();
    8.         Scanner sc = new Scanner(System.in);
    9.  
    10.         while (true) {
    11.             System.out.println("-------------欢迎来到ZZULI学生管理系统-------------");
    12.             System.out.println("请选择操作 1登录 2注册 3忘记密码 4退出");
    13.             String choose = sc.next();
    14.             switch (choose) {
    15.                 case "1" -> Login(list);
    16.                 case "2" -> Register(list);
    17.                 case "3" -> ForgetPassword(list);
    18.                 case "4" -> {
    19.                     System.out.println("谢谢使用，再见");
    20.                     System.exit(0);
    21.                 }
    22.                 default -> System.out.println("没有这个选项");
    23.             }
    24.         }
    25.     }
    26.  
    27. //忘记密码
    28.     private static void ForgetPassword(ArrayList<User> list) {
    29.         System.out.println("忘记密码");
    30.         Scanner sc = new Scanner(System.in);
    31.         //1，键盘录入用户名，判断当前用户名是否存在，如不存在，直接结束方法，并提示：未注册
    32.         //2，键盘录入身份证号码和手机号码
    33.         //3，判断当前用户的身份证号码和手机号码是否一致，
    34.         //如果一致，则提示输入密码，进行修改。
    35.         //如果不一致，则提示：账号信息不匹配，修改失败。
    36.         System.out.println("请输入用户名");
    37.         String username = sc.next();
    38.         boolean flag = contains(list, username);
    39.         if(!flag){
    40.             System.out.println("用户名"+"“"+ username+"”"+"不存在，请先注册");
    41.             return;
    42.         }
    43.  
    44.         System.out.println("请输入身份证号");
    45.         String personID = sc.next();
    46.         System.out.println("请输入手机号");
    47.         String phoneNumber = sc.next();
    48.  
    49.         //获取用户对象在集合中的位置
    50.         int index=findIndex(list,username);
    51.         User user = list.get(index);
    52.         //判断当前用户的身份证号码和手机号码是否一致，
    53.         if(!(user.getPersonID().equalsIgnoreCase(personID)&&user.getPhoneNumber().equals(phoneNumber))){
    54.             System.out.println("身份证号码或手机号码输入有误，不能修改密码");
    55.             return;
    56.         }
    57.         String password;
    58.         while (true) {
    59.             System.out.println("请输入新密码");
    60.             password = sc.next();
    61.             System.out.println("请再次输入新密码");
    62.             String password1 = sc.next();
    63.             if(password1.equals(password)){
    64.                 System.out.println("密码修改成功");
    65.                 break;
    66.             }else {
    67.                 System.out.println("两次输入密码不一致，请重新输入");
    68.             }
    69.         }
    70.         user.setPassword(password);
    71.     }
    72.  
    73.     private static int findIndex(ArrayList<User> list, String username) {
    74.         for (int i = 0; i < list.size(); i++) {
    75.             User user = list.get(i);
    76.             if(user.getUsername().equals(username)){
    77.                 return i;
    78.             }
    79.         }
    80.         return -1;
    81.     }
    82.  
    83. //注册
    84.     private static void Register(ArrayList<User> list) {
    85.         System.out.println("注册");
    86.         Scanner sc = new Scanner(System.in);
    87.         String username,password,personID,phoneNumber ;
    88.         //用户名
    89.         while (true) {
    90.             System.out.println("请输入用户名");
    91.             username = sc.next();
    92.             //验证要求：
    93.             //用户名长度必须在3~15位之间
    94.             //只能是字母加数字的组合，但是不能是纯数字
    95.             boolean flag1 = cheekUsername(username);
    96.             if(!flag1){
    97.                 System.out.println("格式不符合条件，请重新输入");
    98.                 continue;
    99.             }
    100.             //用户名唯一
    101.             boolean flag2 =contains(list,username);
    102.             if(flag2){
    103.                 System.out.println("用户名"+"“"+ username+"”"+"已经存在，请重新输入");
    104.             }else {
    105.                 System.out.println("用户名"+"“"+ username+"”"+"可用，请继续输入信息");
    106.                 break;
    107.             }
    108.         }
    109.         //密码
    110.         while (true) {
    111.             //密码键盘输入两次
    112.             // 两次一致才可以进行注册
    113.             System.out.println("请输入登录密码");
    114.             password = sc.next();
    115.             System.out.println("请再次输入登录密码");
    116.             String password2 = sc.next();
    117.             if(!password.equals(password2)){
    118.                 System.out.println("两次密码不一致，请再次输入");
    119.             }else {
    120.                 System.out.println("两次密码一致，请继续输入信息");
    121.                 break;
    122.             }
    123.         }
    124.         //身份证
    125.         while (true) {
    126.             //验证要求：
    127.             //长度为18位
    128.             //不能以0为开头
    129.             //前17位，必须都是数字
    130.             //最为一位可以是数字，也可以是大写X或小写x
    131.             System.out.println("请输入身份证号");
    132.             personID = sc.next();
    133.             boolean flag = cheekPersonID(personID);
    134.             if(flag){
    135.                 System.out.println("身份证号符合条件，请继续输入信息");
    136.                 break;
    137.             }else {
    138.                 System.out.println("身份证号不符合条件，请重新输入");
    139.             }
    140.         }
    141.         //手机号
    142.         while (true) {
    143.             //验证要求：
    144.             //长度为11位
    145.             //不能以0为开头
    146.             //必须都是数字
    147.             System.out.println("请输入手机号");
    148.             phoneNumber = sc.next();
    149.             boolean flag = cheekPhoneNumber(phoneNumber);
    150.             if(flag){
    151.                 System.out.println("手机号符合条件");
    152.                 break;
    153.             }else{
    154.                 System.out.println("手机号不符合条件，请重新输入");
    155.             }
    156.         }
    157.         //将用户信息放入用户对象中
    158.         User u = new User(username,password,personID,phoneNumber);
    159.         //把用户对象添加到集合中
    160.         list.add(u);
    161.         System.out.println("注册成功");
    162.         printlist(list);
    163.     }
    164.  
    165. //注册中使用的方法
    166.     private static void printlist(ArrayList<User> list) {
    167.     for (int i = 0; i < list.size(); i++) {
    168.         User u = list.get(i);
    169.         System.out.println(u.getUsername()+","+u.getPersonID()+","+u.getPassword()+","+u.getPhoneNumber());
    170.     }
    171. }
    172.  
    173.     private static boolean cheekPhoneNumber(String phoneNumber) {
    174.         //长度为11位
    175.         if(phoneNumber.length()!=11){
    176.             return false;
    177.         }
    178.         //不能以0为开头
    179.         if(phoneNumber.startsWith("0")){
    180.             return false;
    181.         }
    182.         //必须都是数字
    183.         for (int i = 0; i < phoneNumber.length(); i++) {
    184.             char c = phoneNumber.charAt(i);
    185.             if(!(c>='0'&&c<='9')){
    186.                 return false;
    187.             }
    188.         }
    189.         return true;
    190.     }
    191.  
    192.     private static boolean cheekPersonID(String personID) {
    193.         //验证要求：
    194.         //长度为18位
    195.         if (personID.length()!=18){
    196.             return false;
    197.         }
    198.         //不能以0为开头
    199.         if(personID.startsWith("0")){
    200.             return false;
    201.         }
    202.         //前17位，必须都是数字
    203.         for (int i = 0; i < personID.length()-1; i++) {
    204.             char c = personID.charAt(i);
    205.             if(!(c>='0'&&c<='9')){
    206.                 return false;
    207.             }
    208.         }
    209.         //最为一位可以是数字，也可以是大写X或小写x
    210.         char end = personID.charAt(17);
    211.         if((end>='0'&&end<='9')||end=='x'||end=='X'){
    212.             return true;
    213.         }else {
    214.             return false;
    215.         }
    216.     }
    217.  
    218.     private static boolean contains(ArrayList<User> list, String username) {
    219.         for (int i = 0; i < list.size(); i++) {
    220.             User user = list.get(i);
    221.             String Username = user.getUsername();
    222.             if(Username.equals(username))
    223.                 return true;
    224.         }
    225.         return false;
    226.     }
    227.  
    228.     private static boolean cheekUsername(String username) {
    229.         //用户名长度必须在3~15位之间
    230.         int len = username.length();
    231.         if(len<3||len>15){
    232.             return false;
    233.         }
    234.         //只能是字母加数字的组合，但是不能是纯数字
    235.         for (int i = 0; i < username.length(); i++) {
    236.             char c = username.charAt(i);
    237.             if(!((c>='a'&&c<='z')||(c>='A'&&c<='Z')||(c>='0'&&c<='9'))){
    238.                 return false;
    239.             }
    240.         }
    241.         //不能是纯数字
    242.         int count = 0;
    243.         for (int i = 0; i < username.length(); i++) {
    244.             char c = username.charAt(i);
    245.             if((c>='a'&&c<='z')||(c>='A'&&c<='Z')){
    246.                 count++;
    247.                 break;
    248.             }
    249.         }
    250.         return count > 0;
    251.     }
    252.  
    253. //登录
    254.     private static void Login(ArrayList<User> list) {
    255.         System.out.println("登录");
    256.         Scanner sc = new Scanner(System.in);
    257.         //用户名如果未注册，直接结束方法，并提示：用户名未注册，请先注册
    258.         for (int i =0;i<3;i++) {
    259.             System.out.println("请输入用户名");
    260.             String username = sc.next();
    261.             boolean flag = contains(list, username);
    262.             if(!flag){
    263.                 System.out.println("用户名"+"“"+ username+"”"+"不存在，请先注册再登录");
    264.                 return;
    265.             }
    266.  
    267.             System.out.println("请输入密码");
    268.             String password = sc.next();
    269.             //判断验证码是否正确，如不正确，重新输入
    270.             while (true) {
    271.                 String rightCode = getCode();
    272.                 System.out.println("当前验证码为"+rightCode);
    273.                 System.out.println("请输入验证码");
    274.                 String code = sc.next();
    275.                 if(code.equalsIgnoreCase(rightCode)){
    276.                     System.out.println("验证码正确");
    277.                     break;
    278.                 }else{
    279.                     System.out.println("验证码错误，请重新输入");
    280.                 }
    281.             }
    282.             //再判断用户名和密码是否正确，有3次机会
    283.             User u = new User(username,password,null,null);
    284.             boolean flag1 = cheekUserInfo(list,u);
    285.             if(flag1){
    286.                 System.out.println("登录成功");
    287.                 //创建对象，进入学生管理系统
    288.                 StudentSystem ss = new StudentSystem();
    289.                 ss.StartStudentSystem();
    290.                 break;
    291.             }else{
    292.                 System.out.println("登录失败，用户名或密码错误");
    293.                 if(i==2){
    294.                     System.out.println("当前账号"+"“"+ username+"”"+"已被锁定，请联系管理员");
    295.                     break;
    296.                 }else{
    297.                     System.out.println("还剩下"+(2-i)+"次机会");
    298.                 }
    299.             }
    300.         }
    301.     }
    302.  
    303.     private static boolean cheekUserInfo(ArrayList<User> list, User u) {
    304.         for (int i = 0; i < list.size(); i++) {
    305.             User user = list.get(i);
    306.             if (user.getUsername().equals(u.getUsername()) && user.getPassword().equals(u.getPassword())) {
    307.                 return true;
    308.             }
    309.         }
    310.         return false;
    311.     }
    312.  
    313. //验证码
    314.     private static String getCode(){
    315.         //长度为5
    316.         //由4位大写或者小写字母和1位数字组成，同一个字母可重复
    317.         //数字可以出现在任意位置
    318.         ArrayList<Character> list = new ArrayList<>();
    319.         for (int i = 0; i < 26; i++) {
    320.             list.add((char) ('a'+i));
    321.             list.add((char) ('A'+i));
    322.         }
    323.         //获取随机四位字母
    324.         StringBuilder sb = new StringBuilder();
    325.         Random r =new Random();
    326.         for (int i = 0; i < 4; i++) {
    327.             //获取随机索引
    328.             int index = r.nextInt(list.size());
    329.             //获取随机字符
    330.             char c = list.get(index);
    331.             //将随机字符添加到sb中
    332.             sb.append(c);
    333.         }
    334.         //获得随机数字
    335.         int number = r.nextInt(10);
    336.         sb.append(number);
    337.         //将字符串变成字符数组，在字符数组中进行修改，最后再创建一个新的字符串
    338.         char[] arr = sb.toString().toCharArray();
    339.         int i = r.nextInt(arr.length);
    340.         char temp = arr[i];
    341.         arr[i]=arr[arr.length-1];
    342.         arr[arr.length-1] = temp;
    343.  
    344.         return new String(arr);
    345.     }
    346. }

    User.java:

    1. public class User {
    2.     private String username;
    3.     private String password;
    4.     private String personID;
    5.     private String phoneNumber;
    6.  
    7.     public User() {
    8.     }
    9.  
    10.     public User(String username, String password, String personID, String phoneNumber) {
    11.         this.username = username;
    12.         this.password = password;
    13.         this.personID = personID;
    14.         this.phoneNumber = phoneNumber;
    15.     }
    16.  
    17.     public String getUsername() {
    18.         return username;
    19.     }
    20.  
    21.     public void setUsername(String username) {
    22.         this.username = username;
    23.     }
    24.  
    25.     public String getPassword() {
    26.         return password;
    27.     }
    28.  
    29.     public void setPassword(String password) {
    30.         this.password = password;
    31.     }
    32.  
    33.     public String getPersonID() {
    34.         return personID;
    35.     }
    36.  
    37.     public void setPersonID(String personID) {
    38.         this.personID = personID;
    39.     }
    40.  
    41.     public String getPhoneNumber() {
    42.         return phoneNumber;
    43.     }
    44.  
    45.     public void setPhoneNumber(String phoneNumber) {
    46.         this.phoneNumber = phoneNumber;
    47.     }
    48. }

    Student.java

    1. public class Student {
    2.     private String id;
    3.     private String name;
    4.     private int age;
    5.     private String address;
    6.  
    7.     public Student() {
    8.     }
    9.  
    10.     public Student(String id, String name, int age, String address) {
    11.         this.id = id;
    12.         this.name = name;
    13.         this.age = age;
    14.         this.address = address;
    15.     }
    16.  
    17.     public String getId() {
    18.         return id;
    19.     }
    20.  
    21.     public void setId(String id) {
    22.         this.id = id;
    23.     }
    24.  
    25.     public String getName() {
    26.         return name;
    27.     }
    28.  
    29.     public void setName(String name) {
    30.         this.name = name;
    31.     }
    32.  
    33.     public int getAge() {
    34.         return age;
    35.     }
    36.  
    37.     public void setAge(int age) {
    38.         this.age = age;
    39.     }
    40.  
    41.     public String getAddress() {
    42.         return address;
    43.     }
    44.  
    45.     public void setAddress(String address) {
    46.         this.address = address;
    47.     }
    48. }

    StartStudentSystem.java:

    1. package StudentSystemPlus;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Scanner;
    5.  
    6. public class StudentSystem {
    7.  
    8.     public static void StartStudentSystem() {
    9.         ArrayList<Student> list = new ArrayList<>();
    10.         loop: while (true) {
    11.             System.out.println("-------------欢迎来到ZZULI学生管理系统-------------");
    12.             System.out.println("1：添加学生");
    13.             System.out.println("2：删除学生");
    14.             System.out.println("3：修改学生");
    15.             System.out.println("4：查询学生");
    16.             System.out.println("5：退出");
    17.             System.out.println("请输入您的选择：");
    18.  
    19.             Scanner sc = new Scanner(System.in);
    20.             String choose = sc.next();
    21.  
    22.             switch (choose){
    23.                 case "1" -> addStudent(list);
    24.                 case "2" -> deleteStudent(list);
    25.                 case "3" -> updateStudent(list);
    26.                 case "4" -> queryStudent(list);
    27.                 case "5" -> {
    28.                     //方法一
    29.                     System.out.println("退出");
    30.                     break loop;
    31.                     //方法二
    32.                     /*System.out.println("退出");
    33.                     System.exit(0);*/
    34.                 }
    35.                 default -> System.out.println("没有这个选项");
    36.             }
    37.         }
    38.     }
    39.  
    40.     //添加学生
    41.     public static void addStudent(ArrayList<Student> list){
    42.         System.out.println("添加学生");
    43.         Scanner sc = new Scanner(System.in);
    44.  
    45.         System.out.println("请输入学的的ID");
    46.         String id = null;
    47.  
    48.         //判断ID是否唯一
    49.         while (true) {
    50.             id = sc.next();
    51.             boolean flag = contains(list, id);
    52.             if(flag){
    53.                 System.out.println("id已经存在，请重新录入");
    54.             }else {
    55.                 break;
    56.             }
    57.         }
    58.  
    59.         System.out.println("请输入学的的姓名");
    60.         String name = sc.next();
    61.  
    62.         System.out.println("请输入学的的年龄");
    63.         int age = sc.nextInt();
    64.  
    65.         System.out.println("请输入学的的家庭住址");
    66.         String address = sc.next();
    67.  
    68.         //创建学生对象，存入学生信息
    69.         Student s = new Student(id,name,age,address);
    70.  
    71.         //将学生对象加入到集合中
    72.         list.add(s);
    73.  
    74.         System.out.println("\n学生信息添加成功");
    75.     }
    76.  
    77.     //删除学生
    78.     public static void deleteStudent(ArrayList<Student> list){
    79.         System.out.println("删除学生");
    80.         Scanner sc = new Scanner(System.in);
    81.         System.out.println("请输入要删除的学生ID");
    82.  
    83.         String id = sc.next();
    84.         //查询ID在集合中的索引
    85.         int index = getIndex(list, id);
    86.  
    87.         //判断索引值
    88.         if(index>=0){
    89.             //如果返回值>=0,删除学生信息
    90.             list.remove(index);
    91.             System.out.println("ID为"+index+"的学生删除成功");
    92.         }else {
    93.             System.out.println("ID不存在，删除失败");
    94.         }
    95.     }
    96.  
    97.     //修改学生
    98.     public static void updateStudent(ArrayList<Student> list){
    99.         System.out.println("修改学生");
    100.         Scanner sc = new Scanner(System.in);
    101.         System.out.println("请输入要修改学生的ID");
    102.  
    103.         String id = sc.next();
    104.  
    105.         int index = getIndex(list, id);
    106.  
    107.         if(index==-1){
    108.             System.out.println("要修改的ID："+id+"不存在,请重新输入");
    109.             return;
    110.         }
    111.  
    112.         Student stu = list.get(index);
    113.  
    114.         System.out.println("请输入新的学生姓名");
    115.         String newName = sc.next();
    116.         stu.setName(newName);
    117.  
    118.         System.out.println("请输入新的学生年龄");
    119.         int newAge = sc.nextInt();
    120.         stu.setAge(newAge);
    121.  
    122.         System.out.println("请输入要新的学生家庭住址");
    123.         String newAddress = sc.next();
    124.         stu.setAddress(newAddress);
    125.  
    126.         System.out.println("学生信息修改成功");
    127.     }
    128.  
    129.     //查询学生
    130.     public static void queryStudent(ArrayList<Student> list){
    131.         System.out.println("查询学生");
    132.         if(list.size() == 0){
    133.             System.out.println("当前无学生信息，请添加后再查询");
    134.             return;
    135.         }
    136.  
    137.         System.out.println("id\t\t姓名\t年龄\t家庭住址");
    138.         for (int i = 0; i < list.size(); i++) {
    139.             Student stu = list.get(i);
    140.             System.out.println(stu.getId()+"\t"+stu.getName()+"\t"+stu.getAge()+"\t"+stu.getAddress());
    141.         }
    142.     }
    143.  
    144.     //判断id是否唯一
    145.     public static boolean contains(ArrayList<Student> list, String id){
    146.         /*for (int i = 0; i < list.size(); i++) {
    147.             Student stu = list.get(i);
    148.             String sid = stu.getId();
    149.             if(sid.equals(id)){
    150.                 return true;
    151.             }
    152.         }
    153.         return false;*/
    154.         return getIndex(list,id) >=0;
    155.     }
    156.  
    157.     //通过ID获取索引的方法
    158.     public static int getIndex(ArrayList<Student> list, String id){
    159.         //遍历集合
    160.         for (int i = 0; i < list.size(); i++) {
    161.             //获取每一个学生对象
    162.             Student stu = list.get(i);
    163.             //获取每一个学生对象ID
    164.             String sid = stu.getId();
    165.             //集合中学生ID和输入的学生ID进行比较
    166.             if(sid.equals(id)){
    167.                 //存在，返回索引
    168.                 return i;
    169.             }
    170.         }
    171.         //循环结束，不存在，返回-1
    172.         return -1;
    173.     }
    174. }

  • 相关阅读:
    spring java 动态获取consul K/V
    基于51单片机定时宠物投喂自动喂食器
    定岗定编设计：企业职能部门定岗定编设计项目成功案例
    Unity 之利用Audio Source（音频源）组件用于播放声音
    centos7 + mysql 8 安装confluence7.19.3
    Springcloud----Seata分布式事务
    贪心，CF 1891C - Smilo and Monsters
    Linux 安装docker-compose 编排工具并启动
    【黄啊码】七夕来了，用JQuery给你女票表白吧
    SpringBoot集成道历（实现道历日期查询）
  • 原文地址：https://blog.csdn.net/qq_61228493/article/details/127434536