• 【Java】学生管理系统-登录、注册、CRUD（附完整代码）

    代码

    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.  
    11.     public Student(String id, String name, int age, String address) {
    12.         this.id = id;
    13.         this.name = name;
    14.         this.age = age;
    15.         this.address = address;
    16.     }
    17.  
    18.     public String getId() {
    19.         return id;
    20.     }
    21.  
    22.     public void setId(String id) {
    23.         this.id = id;
    24.     }
    25.  
    26.     public String getName() {
    27.         return name;
    28.     }
    29.  
    30.     public void setName(String name) {
    31.         this.name = name;
    32.     }
    33.  
    34.     public int getAge() {
    35.         return age;
    36.     }
    37.  
    38.     public void setAge(int age) {
    39.         this.age = age;
    40.     }
    41.  
    42.     public String getAddress() {
    43.         return address;
    44.     }
    45.  
    46.     public void setAddress(String address) {
    47.         this.address = address;
    48.     }
    49. }
    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 = new ArrayList<>();
    8.         System.out.println("录入数据中...");
    9.         User u1 = new User("zhangsan", "123", "610302195607011642", "13669125183");
    10.         User u2 = new User("lisi", "456", "620502196006248385", "13363222321");
    11.         User u3 = new User("wangwu", "789", "512731188706034846", "13765642332");
    12.         User u4 = new User("zhaoliu", "123456", "140725184710194731", "13464323579");
    13.  
    14.         user.add(u1);
    15.         user.add(u2);
    16.         user.add(u3);
    17.         user.add(u4);
    18.  
    19.         System.out.println("录入完毕");
    20.  
    21.         String username;
    22.         String password;
    23.         String id;
    24.         String phoneNumber;
    25.  
    26.         Scanner sc1 = new Scanner(System.in);
    27.  
    28.         while (true) {
    29.             System.out.println("欢迎来到学生管理系统");
    30.             System.out.println("请选择操作1登录 2注册 3忘记密码");
    31.             int select = sc1.nextInt();
    32.             switch (select) {
    33.                 case 1:
    34.                     while (true) {
    35.                         System.out.println("登录");
    36.                         System.out.println("请输入用户名：（输入-1，则返回登录界面）");
    37.                         username = sc1.next();
    38.                         if (username.equals("-1")) {
    39.                             break;
    40.                         }
    41.                         if (login(username, user)) {
    42.                             System.out.println("登录成功");
    43. //                            StudentSytstem studentSytstem = new StudentSytstem();
    44.                             StudentSytstem.start();
    45.                             // showAll(user);
    46.                             break;
    47.                         } else {
    48.                             System.out.println("登录失败");
    49.                             System.out.println("-----------------------------------------");
    50.                         }
    51.                     }
    52.                     break;
    53.                 case 2:
    54.                     while (true) {
    55.                         System.out.println("注册");
    56.                         System.out.println("请输入用户名：（输入-1，则返回登录界面）");
    57.                         username = sc1.next();
    58.                         if (!usernameRule(username)) {
    59.                             System.out.println("username格式错误");
    60.                             System.out.println("用户名唯一" + "\n" +
    61.                                     "用户名长度必须在3~15位之间" + "\n" +
    62.                                     "只能是字母加数字的组合，但是不能是纯数字");
    63.                             System.out.println("-----------------------------------------");
    64.                             continue;
    65.                         }
    66.                         if (username.equals("-1")) {
    67.                             break;
    68.                         }
    69.                         if (register(username, user)) {
    70.                             System.out.println("注册成功");
    71.                             printList(user);
    72.                             System.out.println("-----------------------------------------");
    73.                             break;
    74.                         } else {
    75.                             System.out.println("删除失败");
    76.                             System.out.println("-----------------------------------------");
    77.                         }
    78.                     }
    79.                     break;
    80.                 case 3:
    81.                     while(true) {
    82.                         System.out.println("忘记密码");
    83.                         System.out.println("请输入username：（输入-1，则返回登录界面）");
    84.                         username = sc1.next();
    85.                         if (username.equals("-1")) {
    86.                             break;
    87.                         }
    88.                         if(forgetPassword(username, user)) {
    89.                             System.out.println("修改成功");
    90.                             System.out.println("-----------------------------------------");
    91.                             break;
    92.                         } else {
    93.                             System.out.println("修改失败");
    94.                             System.out.println("-----------------------------------------");
    95.                         }
    96.                     }
    97.  
    98.                     break;
    99.  
    100.                 case 4:
    101.                     System.out.println("谢谢使用，再见！");
    102.                     System.exit(0);
    103.                     break;
    104.                 default:
    105.                     System.out.println("没有这个选项");
    106.                     break;
    107.             }
    108.         }
    109.     }
    110.  
    111.     private static void printList(ArrayList user) {
    112.         System.out.println(String.format(
    113.                 String.format("%-16s |", "姓名") +
    114.                 String.format("%-8s |", "密码") +
    115.                 String.format("%-18s |", "身份证号") +
    116.                 String.format("%-8s |", "手机号码")));
    117.  
    118.         for (int i = 0; i < user.size(); i++) {
    119.             System.out.print(String.format("%-16s |", user.get(i).getUsername()));
    120.             System.out.print(String.format("%-8s |", user.get(i).getPassword()));
    121.             System.out.print(String.format("%-18s |", user.get(i).getId()));
    122.             System.out.print(String.format("%-8s |", user.get(i).getPhoneNumber()));
    123.             System.out.println();
    124.         }
    125.     }
    126.  
    127.     public static boolean login(String username, ArrayList user) {
    128.         Scanner sc2 = new Scanner(System.in);
    129.         /*
    130.         * // 生成四位随机数字的验证码，取消注释
    131.         * Random random = new Random();
    132.         * int randomNumber = random.nextInt(9000) + 1000;
    133.         */
    134.  
    135.         for (int i = 0; i < user.size(); i++) {
    136.             if (username.equals(user.get(i).getUsername())){
    137.                 System.out.println("请输入密码：");
    138.                 String password = sc2.next();
    139.                 // 生成四位随机数字的验证码，替换下一行代码
    140.                 // String generate_code = String.valueOf(randomNumber);
    141.                 String generate_code = getCode();
    142.                 System.out.println("验证码为：" + generate_code);
    143.                 System.out.println("请输入验证码：");
    144.                 String code = sc2.next();
    145.                 if (user.get(i).getPassword().equals(password) && generate_code.equals(code)) {
    146.                     System.out.println("密码或验证码错误！");
    147.                     return true;
    148.                 }
    149.             }
    150.         }
    151.         System.out.println("用户不存在");
    152.         return false;
    153.     }
    154.  
    155.     public static boolean register(String username, ArrayList user) {
    156.         for (int i = 0; i < user.size(); i++) {
    157.             if (username.equals(user.get(i).getUsername())){
    158.                 System.out.println("用户名已存在，不能录入");
    159.                 return false;
    160.             }
    161.         }
    162.  
    163.         Scanner sc3 = new Scanner(System.in);
    164.  
    165.         String password1, password2;
    166.         while (true) {
    167.             System.out.println("请输入password：");
    168.             password1 = sc3.next();
    169.             System.out.println("请重新输入一次password：");
    170.             password2 = sc3.next();
    171.             if (password1.equals(password2)) {
    172.                 break;
    173.             }
    174.             System.out.println("两次输入的password不一样，请重新输入");
    175.         }
    176.  
    177.         while (true) {
    178.             System.out.println("请输入id：");
    179.             String id = sc3.next();
    180.             if (!idRule(id)) {
    181.                 System.out.println("id格式错误，请重新输入id：");
    182.                 continue;
    183.             }
    184.             System.out.println("请输入phoneNumber：");
    185.             String phoneNumber = sc3.next();
    186.             if (!phoneNumberRule(phoneNumber)) {
    187.                 System.out.println("phoneNumber格式错误，请重新输入phoneNumber：");
    188.                 continue;
    189.             }
    190.             User u = new User(username, password1, id, phoneNumber);
    191.             user.add(u);
    192.             return true;
    193.         }
    194.     }
    195.  
    196.     public static boolean forgetPassword(String username,  ArrayList user) {
    197.         Scanner sc4 = new Scanner(System.in);
    198.         for (int i = 0; i < user.size(); i++) {
    199.             if (!username.equals(user.get(i).getUsername())){
    200.                 System.out.println("用户名不存在，不能修改密码");
    201.                 return false;
    202.             } else {
    203.                 while (true) {
    204.                     System.out.println("请输入id：");
    205.                     String id = sc4.next();
    206.                     if (!idRule(id)) {
    207.                         System.out.println("id格式错误");
    208.                         continue;
    209.                     }
    210.                     System.out.println("请输入phoneNumber：");
    211.                     String phoneNumber = sc4.next();
    212.                     if (!phoneNumberRule(phoneNumber)) {
    213.                         System.out.println("phoneNumber格式错误");
    214.                         continue;
    215.                     }
    216.                     if (id.equals(user.get(i).getId()) && phoneNumber.equals(user.get(i).getPhoneNumber())) {
    217.                         System.out.println("请输入要修改的password：");
    218.                         String new_password =sc4.next();
    219.                         user.get(i).setPassword(new_password);
    220.                         return true;
    221.                     }
    222.                 }
    223.             }
    224.         }
    225.         System.out.println("账号信息不匹配，修改失败");
    226.         return false;
    227.     }
    228.  
    229.     // 到len为止全是数字
    230.     public static boolean isNumber(String target, int len) {
    231.         boolean flag = true;
    232.         for (int i = len;--i>=0;){
    233.             if (!Character.isDigit(target.charAt(i))){
    234.                 flag = false;
    235.             }
    236.         }
    237.         if (flag)
    238.             return true;
    239.         return false;
    240.     }
    241.  
    242.     /*
    243.      * 不使用正则表达式，判断用户名
    244.      */
    245.     public static boolean usernameRule(String username) {
    246.         int length = username.length();
    247.         if ((length >= 3 && length <= 15) && !(isNumber(username, length))){
    248.             return true;
    249.         }
    250.         return false;
    251.     }
    252.  
    253.     public static boolean idRule(String id) {
    254.         int length = id.length();
    255.         if (length == 18
    256.                 && !(id.charAt(0) == '0')
    257.                 && isNumber(id, 17)
    258.                 && ((isNumber(String.valueOf(id.charAt(17)), 1)) || id.endsWith("X") || id.endsWith("x"))) {
    259.             return true;
    260.         }
    261.         return false;
    262.     }
    263.  
    264.     public static boolean phoneNumberRule(String phoneNumber) {
    265.         int length = phoneNumber.length();
    266.         if (length == 11
    267.                 && !(phoneNumber.startsWith("0"))
    268.                 && isNumber(phoneNumber, 11)) {
    269.             return true;
    270.         }
    271.         return false;
    272.     }
    273.  
    274.     private static String getCode() {
    275.         //1.创建一个集合添加所有的大写和小写字母
    276.         ArrayList list = new ArrayList<>();
    277.         for (int i = 0; i < 26; i++) {
    278.             list.add((char) ('a' + i));
    279.             list.add((char) ('A' + i));
    280.         }
    281.  
    282.         StringBuilder sb = new StringBuilder();
    283.         //2.要随机抽取4个字符
    284.         Random r = new Random();
    285.         for (int i = 0; i < 4; i++) {
    286.             //获取随机索引
    287.             int index = r.nextInt(list.size());
    288.             //利用随机索引获取字符
    289.             char c = list.get(index);
    290.             //把随机字符添加到sb当中
    291.             sb.append(c);
    292.         }
    293.  
    294.         //3.把一个随机数字添加到末尾
    295.         int number = r.nextInt(10);
    296.         sb.append(number);
    297.  
    298.         //4.如果我们要修改字符串中的内容
    299.         //先把字符串变成字符数组，在数组中修改，然后再创建一个新的字符串
    300.         char[] arr = sb.toString().toCharArray();
    301.         //拿着最后一个索引，跟随机索引进行交换
    302.         int randomIndex = r.nextInt(arr.length);
    303.         //最大索引指向的元素 跟随机索引指向的元素交换
    304.         char temp = arr[randomIndex];
    305.         arr[randomIndex] = arr[arr.length - 1];
    306.         arr[arr.length - 1] = temp;
    307.         return new String(arr);
    308.  
    309.     }
    310. }
    311.  
    312.  

    1. import java.util.ArrayList;
    2. import java.util.Random;
    3. import java.util.Scanner;
    4.  
    5. public class App {
    6.     static  ArrayList user = new ArrayList<>();
    7.     static {
    8.         System.out.println("录入数据中...");
    9.         User u1 = new User("zhangsan", "123", "610302195607011642", "13669125183");
    10.         User u2 = new User("lisi", "456", "620502196006248385", "13363222321");
    11.         User u3 = new User("wangwu", "789", "512731188706034846", "13765642332");
    12.         User u4 = new User("zhaoliu", "123456", "140725184710194731", "13464323579");
    13.  
    14.         user.add(u1);
    15.         user.add(u2);
    16.         user.add(u3);
    17.         user.add(u4);
    18.  
    19.         System.out.println("录入完毕");
    20.     }
    21.  
    22.     public static void main(String[] args) throws InterruptedException {
    23.         String username;
    24.         String password;
    25.         String id;
    26.         String phoneNumber;
    27.  
    28.         Scanner sc1 = new Scanner(System.in);
    29.  
    30.         while (true) {
    31.             System.out.println("欢迎来到学生管理系统");
    32.             System.out.println("请选择操作1登录 2注册 3忘记密码");
    33.             int select = sc1.nextInt();
    34.             switch (select) {
    35.                 case 1:
    36.                     while (true) {
    37.                         System.out.println("登录");
    38.                         System.out.println("请输入用户名：（输入-1，则返回登录界面）");
    39.                         username = sc1.next();
    40.                         if (username.equals("-1")) {
    41.                             break;
    42.                         }
    43.                         if (login(username, user)) {
    44.                             System.out.println("登录成功");
    45.                             // StudentSytstem studentSytstem = new StudentSytstem();
    46.                             StudentSytstem.start();
    47.                             // showAll(user);
    48.                             break;
    49.                         } else {
    50.                             System.out.println("登录失败");
    51.                             System.out.println("-----------------------------------------");
    52.                         }
    53.                     }
    54.                     break;
    55.                 case 2:
    56.                     while (true) {
    57.                         System.out.println("注册");
    58.                         System.out.println("请输入用户名：（输入-1，则返回登录界面）");
    59.                         username = sc1.next();
    60.                         if (!usernameRule(username)) {
    61.                             System.out.println("username格式错误");
    62.                             System.out.println("用户名唯一" + "\n" +
    63.                                     "用户名长度必须在3~15位之间" + "\n" +
    64.                                     "只能是字母加数字的组合，但是不能是纯数字");
    65.                             System.out.println("-----------------------------------------");
    66.                             continue;
    67.                         }
    68.                         if (username.equals("-1")) {
    69.                             break;
    70.                         }
    71.                         if (register(username, user)) {
    72.                             System.out.println("注册成功");
    73.                             System.out.println("-----------------------------------------");
    74.                             break;
    75.                         } else {
    76.                             System.out.println("删除失败");
    77.                             System.out.println("-----------------------------------------");
    78.                         }
    79.                     }
    80.                     break;
    81.                 case 3:
    82.                     while(true) {
    83.                         System.out.println("忘记密码");
    84.                         System.out.println("请输入username：（输入-1，则返回登录界面）");
    85.                         username = sc1.next();
    86.                         if (username.equals("-1")) {
    87.                             break;
    88.                         }
    89.                         if(forgetPassword(username, user)) {
    90.                             System.out.println("修改成功");
    91.                             System.out.println("-----------------------------------------");
    92.                             break;
    93.                         } else {
    94.                             System.out.println("修改失败");
    95.                             System.out.println("-----------------------------------------");
    96.                         }
    97.                     }
    98.  
    99.                     break;
    100.  
    101.                 case 4:
    102.                     System.out.println("谢谢使用，再见！");
    103.                     System.exit(0);
    104.                     break;
    105.                 default:
    106.                     System.out.println("没有这个选项");
    107.                     break;
    108.             }
    109.         }
    110.     }
    111.  
    112.     public static boolean login(String username, ArrayList user) throws InterruptedException {
    113.         Scanner sc2 = new Scanner(System.in);
    114.         /*
    115.         * // 生成四位随机数字的验证码，取消注释
    116.         * Random random = new Random();
    117.         * int randomNumber = random.nextInt(9000) + 1000;
    118.         */
    119.  
    120.  
    121.         for (int i = 0; i < user.size(); i++) {
    122.             if (username.equals(user.get(i).getUsername())){
    123.                 for (int j = 0; j < 3; j++) {
    124.                     System.out.println("请输入密码：");
    125.                     String password = sc2.next();
    126.                     // 生成四位随机数字的验证码，替换下一行代码
    127.                     // String generate_code = String.valueOf(randomNumber);
    128.                     String generate_code = getCode();
    129.                     System.out.println("验证码为：" + generate_code);
    130.                     System.out.println("请输入验证码：");
    131.                     String code = sc2.next();
    132.                     if (user.get(i).getPassword().equals(password) && generate_code.equals(code)) {
    133.                         return true;
    134.                     }
    135.                     if (j == 2) {
    136.                         System.out.println("当前系统被锁定3秒");
    137.                         Thread.sleep(3000);
    138.                     } else {
    139.                         System.out.println("用户名、密码或验证码错误，还剩下" + (2 - j) + "次机会");
    140.                     }
    141.                 }
    142.             }
    143.         }
    144.  
    145.         System.out.println("当前用户" + username + "不存在，请先注册");
    146.         return false;
    147.     }
    148.  
    149.     public static boolean register(String username, ArrayList user) {
    150.         for (int i = 0; i < user.size(); i++) {
    151.             if (username.equals(user.get(i).getUsername())){
    152.                 System.out.println("用户名已存在，不能反复注册");
    153.                 return false;
    154.             }
    155.         }
    156.  
    157.         Scanner sc3 = new Scanner(System.in);
    158.  
    159.         String password1, password2;
    160.         while (true) {
    161.             System.out.println("请输入password：");
    162.             password1 = sc3.next();
    163.             System.out.println("请重新输入一次password：");
    164.             password2 = sc3.next();
    165.             if (password1.equals(password2)) {
    166.                 break;
    167.             }
    168.             System.out.println("两次输入的password不一样，请重新输入");
    169.         }
    170.  
    171.         while (true) {
    172.             System.out.println("请输入id：");
    173.             String id = sc3.next();
    174.             if (!idRule(id)) {
    175.                 System.out.println("id格式错误，请重新输入id：");
    176.                 continue;
    177.             }
    178.             System.out.println("请输入phoneNumber：");
    179.             String phoneNumber = sc3.next();
    180.             if (!phoneNumberRule(phoneNumber)) {
    181.                 System.out.println("phoneNumber格式错误，请重新输入phoneNumber：");
    182.                 continue;
    183.             }
    184.             User u = new User(username, password1, id, phoneNumber);
    185.             user.add(u);
    186.             System.out.println(
    187.                     String.format("%-16s|", "姓名") +
    188.                     String.format("%-8s|", "密码") +
    189.                     String.format("%-18s|", "身份证号") +
    190.                     String.format("%-8s|", "手机号码"));
    191.             System.out.print(String.format("%-16s|", username));
    192.             System.out.print(String.format("%-8s|", password1));
    193.             System.out.print(String.format("%-18s|", id));
    194.             System.out.print(String.format("%-8s", phoneNumber));
    195.             System.out.println();
    196.             return true;
    197.         }
    198.     }
    199.  
    200.     public static boolean forgetPassword(String username,  ArrayList user) {
    201.         Scanner sc4 = new Scanner(System.in);
    202.         for (int i = 0; i < user.size(); i++) {
    203.             if (!username.equals(user.get(i).getUsername())){
    204.                 System.out.println("用户名不存在，不能修改密码,请先注册");
    205.                 return false;
    206.             } else {
    207.                 while (true) {
    208.                     System.out.println("请输入id：");
    209.                     String id = sc4.next();
    210.                     if (!idRule(id)) {
    211.                         System.out.println("id格式错误");
    212.                         continue;
    213.                     }
    214.                     System.out.println("请输入phoneNumber：");
    215.                     String phoneNumber = sc4.next();
    216.                     if (!phoneNumberRule(phoneNumber)) {
    217.                         System.out.println("phoneNumber格式错误");
    218.                         continue;
    219.                     }
    220.                     if (id.equals(user.get(i).getId()) && phoneNumber.equals(user.get(i).getPhoneNumber())) {
    221.                         System.out.println("请输入要修改的password：");
    222.                         String new_password =sc4.next();
    223.                         // 如果想要校验密码，仿照上面的就行，这里不重复了
    224.                         user.get(i).setPassword(new_password);
    225.                         return true;
    226.                     }
    227.                 }
    228.             }
    229.         }
    230.         System.out.println("账号信息不匹配，修改失败");
    231.         return false;
    232.     }
    233.  
    234.     // 到len为止全是数字
    235.     public static boolean isNumber(String target, int len) {
    236.         boolean flag = true;
    237.         for (int i = len;--i>=0;){
    238.             if (!Character.isDigit(target.charAt(i))){
    239.                 flag = false;
    240.             }
    241.         }
    242.         if (flag)
    243.             return true;
    244.         return false;
    245.     }
    246.  
    247.     /*
    248.      * 不使用正则表达式，判断用户名
    249.      */
    250.     public static boolean usernameRule(String username) {
    251.         int length = username.length();
    252.         if ((length >= 3 && length <= 15) && !(isNumber(username, length))){
    253.             return true;
    254.         }
    255.         return false;
    256.     }
    257.  
    258.     public static boolean idRule(String id) {
    259.         int length = id.length();
    260.         if (length == 18
    261.                 && !(id.charAt(0) == '0')
    262.                 && isNumber(id, 17)
    263.                 && ((isNumber(String.valueOf(id.charAt(17)), 1)) || id.endsWith("X") || id.endsWith("x"))) {
    264.             return true;
    265.         }
    266.         return false;
    267.     }
    268.  
    269.     public static boolean phoneNumberRule(String phoneNumber) {
    270.         int length = phoneNumber.length();
    271.         if (length == 11
    272.                 && !(phoneNumber.startsWith("0"))
    273.                 && isNumber(phoneNumber, 11)) {
    274.             return true;
    275.         }
    276.         return false;
    277.     }
    278.  
    279.     private static String getCode() {
    280.         //1.创建一个集合添加所有的大写和小写字母
    281.         ArrayList list = new ArrayList<>();
    282.         for (int i = 0; i < 26; i++) {
    283.             list.add((char) ('a' + i));
    284.             list.add((char) ('A' + i));
    285.         }
    286.  
    287.         StringBuilder sb = new StringBuilder();
    288.         //2.要随机抽取4个字符
    289.         Random r = new Random();
    290.         for (int i = 0; i < 4; i++) {
    291.             //获取随机索引
    292.             int index = r.nextInt(list.size());
    293.             //利用随机索引获取字符
    294.             char c = list.get(index);
    295.             //把随机字符添加到sb当中
    296.             sb.append(c);
    297.         }
    298.  
    299.         //3.把一个随机数字添加到末尾
    300.         int number = r.nextInt(10);
    301.         sb.append(number);
    302.  
    303.         //4.如果我们要修改字符串中的内容
    304.         //先把字符串变成字符数组，在数组中修改，然后再创建一个新的字符串
    305.         char[] arr = sb.toString().toCharArray();
    306.         //拿着最后一个索引，跟随机索引进行交换
    307.         int randomIndex = r.nextInt(arr.length);
    308.         //最大索引指向的元素 跟随机索引指向的元素交换
    309.         char temp = arr[randomIndex];
    310.         arr[randomIndex] = arr[arr.length - 1];
    311.         arr[arr.length - 1] = temp;
    312.         return new String(arr);
    313.  
    314.     }
    315. }

    1. import java.util.ArrayList;
    2. import java.util.Scanner;
    3.  
    4. public class StudentSytstem {
    5.     private static final String ADD_STUDENT = "1";
    6.     private static final String DELE_STUDENT = "2";
    7.     private static final String UPDATE_STUDENT = "3";
    8.     private static final String QUERY_STUDENT = "4";
    9.     private static final String ALL_STUDENT = "5";
    10.     private static final String LOGIN = "6";
    11.     private static final String EXIT = "7";
    12.  
    13.     static ArrayList student = new ArrayList<>();
    14.  
    15.     static {
    16.         System.out.println("录入数据中...");
    17.         Student s1 = new Student("001", "张三", 23, "南京");
    18.         Student s2 = new Student("002", "李四", 24, "北京");
    19.         Student s3 = new Student("003", "王五", 25, "广州");
    20.         Student s4 = new Student("004", "赵六", 26, "深圳");
    21.  
    22.         student.add(s1);
    23.         student.add(s2);
    24.         student.add(s3);
    25.         student.add(s4);
    26.  
    27.         System.out.println("录入完毕");
    28.     }
    29.  
    30.     public static void start() throws InterruptedException {
    31.  
    32.         ArrayList student = new ArrayList<>();
    33.         System.out.println("录入数据中...");
    34.         Student s1 = new Student("001", "张三", 23, "南京");
    35.         Student s2 = new Student("002", "李四", 24, "北京");
    36.         Student s3 = new Student("003", "王五", 25, "广州");
    37.         Student s4 = new Student("004", "赵六", 26, "深圳");
    38.  
    39.         student.add(s1);
    40.         student.add(s2);
    41.         student.add(s3);
    42.         student.add(s4);
    43.  
    44.         System.out.println("录入完毕");
    45.  
    46.         Scanner sc = new Scanner(System.in);
    47.         String id;
    48.         String name;
    49.         int age;
    50.         String address;
    51.         while(true) {
    52.             System.out.println(
    53.                     "--------------欢迎来到学生管理系统-----------------" + "\n" +
    54.                             "1：添加学生" + "\n" +
    55.                             "2：删除学生" + "\n" +
    56.                             "3：修改学生" + "\n" +
    57.                             "4：查询学生" + "\n" +
    58.                             "5：所有学生" + "\n" +
    59.                             "6：返回登录界面" + "\n" +
    60.                             "7：退出系统" + "\n" +
    61.                             "请输入您的选择:");
    62.             int select = sc.nextInt();
    63.             switch (select) {
    64.                 case ADD_STUDENT:
    65.                     while(true) {
    66.                         System.out.println("添加");
    67.                         System.out.println("请输入id：（输入-1，则返回主菜单）");
    68.                         id = sc.next();
    69.                         if (id.equals("-1")) {
    70.                             break;
    71.                         }
    72.                         if (addStudent(id, student)) {
    73.                             System.out.println("添加成功");
    74.                             showAll(student);
    75.                             break;
    76.                         } else {
    77.                             System.out.println("添加失败");
    78.                         }
    79.                     }
    80.                     break;
    81.                 case DELE_STUDENT:
    82.                     while (true) {
    83.                         System.out.println("删除");
    84.                         System.out.println("请输入id：（输入-1，则返回主菜单）");
    85.                         id = sc.next();
    86.                         if (id.equals("-1")) {
    87.                             break;
    88.                         }
    89.                         if (deleteStudent(id, student)) {
    90.                             System.out.println("删除成功");
    91.                             showAll(student);
    92.                             break;
    93.                         } else {
    94.                             System.out.println("删除失败");
    95.                         }
    96.                     }
    97.  
    98.                     break;
    99.                 case UPDATE_STUDENT:
    100.                     while(true) {
    101.                         System.out.println("修改");
    102.                         System.out.println("请输入id：（输入-1，则返回主菜单）");
    103.                         id = sc.next();
    104.                         if (id.equals("-1")) {
    105.                             break;
    106.                         }
    107.                         if(updateStudent(id, student)) {
    108.                             System.out.println("修改成功");
    109.                             showAll(student);
    110.                             break;
    111.                         } else {
    112.                             System.out.println("修改失败");
    113.                         }
    114.                     }
    115.  
    116.                     break;
    117.                 case QUERY_STUDENT:
    118.                     while(true) {
    119.                         System.out.println("查询");
    120.                         System.out.println("请输入id：（输入-1，则返回主菜单）");
    121.                         id = sc.next();
    122.                         if (id.equals("-1")) {
    123.                             break;
    124.                         }
    125.                         if (queryStudent(id, student) != null) {
    126.                             Student s = queryStudent(id, student);
    127.                             System.out.println("id\t\t\t姓名\t\t年龄\t\t家庭住址");
    128.                             System.out.print(s.getId() + "\t");
    129.                             System.out.print(s.getName() + "\t\t");
    130.                             System.out.print(s.getAge() + "\t\t");
    131.                             System.out.print(s.getAddress());
    132.                             System.out.println();
    133.                             break;
    134.                         } else {
    135.                             System.out.println("查找失败");
    136.                         }
    137.                     }
    138.  
    139.                     break;
    140.                 case ALL_STUDENT:
    141.                     System.out.println("所有学生");
    142.                     showAll(student);
    143.                     break;
    144.                 case LOGIN:
    145.                     System.out.println("返回登录界面");
    146.                     String[] args = {""};
    147.                     App.main(args);
    148.                 case EXIT:
    149.                     System.out.println("退出系统");
    150.                     System.exit(0);
    151.                 default:
    152.                     System.out.println("没有这个选项");
    153.                     break;
    154.             }
    155.         }
    156.  
    157.     }
    158.  
    159.     private static Student queryStudent(String id, ArrayList student) {
    160.         if (student.size() == 0) {
    161.             System.out.println("当前无学生信息，请添加后再查询");
    162.             return null;
    163.         }
    164.         for (int i = 0; i < student.size(); i++) {
    165.             if (id.equals(student.get(i).getId())) {
    166.                 Student s = student.get(i);
    167.                 return s;
    168.             }
    169.         }
    170.         return null;
    171.     }
    172.  
    173.     private static boolean updateStudent(String id, ArrayList student) {
    174.         Scanner sc = new Scanner(System.in);
    175.         for (int i = 0; i < student.size(); i++) {
    176.             if (id.equals(student.get(i).getId())) {
    177.                 System.out.println(student.get(i).getName());
    178.                 System.out.println("请输入修改的姓名：");
    179.                 String new_name = sc.next();
    180.                 System.out.println(student.get(i).getAge());
    181.                 System.out.println("请输入修改的年龄：");
    182.                 int new_age = sc.nextInt();
    183.                 System.out.println(student.get(i).getAddress());
    184.                 System.out.println("请输入修改的地址：");
    185.                 String new_address = sc.next();
    186.                 Student s = new Student(id, new_name, new_age, new_address);
    187.                 student.set(i, s);
    188.                 return true;
    189.             }
    190.         }
    191.         System.out.println("id不存在");
    192.         return false;
    193.     }
    194.  
    195.     private static boolean deleteStudent(String id, ArrayList student) {
    196.         for (int i = 0; i < student.size(); i++) {
    197.             if (id.equals(student.get(i).getId())) {
    198.                 student.remove(i);
    199.                 return true;
    200.             }
    201.         }
    202.         return false;
    203.     }
    204.  
    205.     private static boolean addStudent(String id, ArrayList student) {
    206.         for (int i = 0; i < student.size(); i++) {
    207.             if (id.equals(student.get(i).getId())){
    208.                 System.out.println("id已存在，不能录入");
    209.                 return false;
    210.             }
    211.         }
    212.  
    213.         Scanner sc = new Scanner(System.in);
    214.         System.out.println("请输入name：");
    215.         String name = sc.next();
    216.         System.out.println("请输入age：");
    217.         int age = sc.nextInt();
    218.         System.out.println("请输入address：");
    219.         String address = sc.next();
    220.         Student s = new Student(id, name, age, address);
    221.         student.add(s);
    222.         return true;
    223.     }
    224.     private static void showAll(ArrayList student) {
    225.         if (student.size() == 0) {
    226.             System.out.println("当前无学生信息，请添加后再查询");
    227.             return;
    228.         }
    229.         for (int i = 0; i < student.size(); i++) {
    230.             if (i == 0) {
    231.                 System.out.println(String.format("%-8s |", "id") + String.format("%-16s |", "姓名") + String.format("%-8s |", "年龄") + String.format("%-8s |", "家庭住址"));
    232.             }
    233.             System.out.print(String.format("%-8s |", student.get(i).getId()));
    234.             System.out.print(String.format("%-16s |", student.get(i).getName()));
    235.             System.out.print(String.format("%-8d |", student.get(i).getAge()));
    236.             System.out.print(String.format("%-8s |", student.get(i).getAddress()));
    237.             System.out.println();
    238.         }
    239.     }
    240. }

    需求

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

    学生类

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

    用户类

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

    学生管理系统登录界面

    注册功能

    1，用户名需要满足以下要求

    验证要求：

    • 用户名唯一
    • 用户名长度必须在3~15位之间
    • 只能是字母加数字的组合，但是不能是纯数字

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

    3，身份证号码需要验证

    验证要求：

    • 长度为18位
    • 不能以0为开头
    • 前17位，必须都是数字
    • 最为一位可以是数字，也可以是大写X或小写x

    4，手机号验证

    • 验证要求：
    • 长度为11位
    • 不能以0为开头
    • 必须都是数字

    登录功能

    1，键盘录入用户名

    2，键盘录入密码

    3，键盘录入验证码

            验证要求：

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

    密码错误3次

    用户不存在 

    忘记密码

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

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

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

    • 如果一致，则提示输入密码，进行修改。
    • 如果不一致，则提示：账号信息不匹配，修改失败。

    验证码规则

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

    添加功能

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

    • id唯一

    删除功能

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

    • id存在删除

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

    修改功能

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

    • id存在，继续录入其他信息

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

    查询功能

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

    • 如果没有学生信息，提示：当前无学生信息，请添加后再查询

    • 如果有学生信息，需要按照格式输出。

    待更新

    1、正则表达式——>判断格式

    2、数据的永久化存储——>登录次数过多，锁定账号 

    更新

    2023/10/24 加入静态代码块

    结论

    系统有较好的健壮性，对于大部分异常输入都会处理。如果发现有未处理的地方，请在评论区告诉我，我会尽快修改，谢谢！

  • 相关阅读:
    Docker镜像打包示例
    Android mtk 系统应用改为可卸载，恢复出厂可恢复
    极空间变身监控录像机，搭配Onvif摄像头，实现实时观看和录制视频回放功能
    [gstreamer] overview of gstreamer
    《canvas》之第1章 canvas概述
    Cmake常用命令（二）
    Linux创建用户及sumba服务器创建用户
    C++中指针的概念和声明
    【设计模式】Java设计模式 - 模板模式
    zabbix添加监控项及邮件报警
  • 原文地址：https://blog.csdn.net/have_to_be/article/details/133930220