Java—简单的控制台版学生管理系统（管理员登录端）（内附完整代码）

MonKingProgrammer

已于 2023-12-17 15:49:07 修改

阅读量1.2k

点赞数 27

文章标签： java 开发语言

于 2023-12-17 15:46:26 首次发布

本文链接：https://blog.csdn.net/Monkan/article/details/135044668

版权

1.代码涉及知识点

一个标准JavaBean类，一个测试类
final关键字和static关键字，静态代码块的使用（同时在上一篇学生管理系统中也可以使用）
JDK14新增的增强switch
ArrayList集合以及其中的方法add
自学写的许多个方法

2.项目大纲

3.需求

4.标准的JavaBean类—用户类

这里首先我们要先自己定义一个Users类，用来存放用户的属性，也就是用户的基本信息，比如：用户名，密码，身份证号码，电话号码等。可以用ptg插件一键生成标准的JavaBean类。

public class Users {
    private String username;
    private String password;
    private String identifyNumber;
    private String telephoneNumber;

    public Users() {
    }

    public Users(String username, String password, String identifyNumber, String telephoneNumber) {
        this.username = username;
        this.password = password;
        this.identifyNumber = identifyNumber;
        this.telephoneNumber = telephoneNumber;
    }

    /**
     * 获取
     * @return username
     */
    public String getUsername() {
        return username;
    }

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

    /**
     * 获取
     * @return password
     */
    public String getPassword() {
        return password;
    }

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

    /**
     * 获取
     * @return identifyNumber
     */
    public String getIdentifyNumber() {
        return identifyNumber;
    }

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

    /**
     * 获取
     * @return telephoneNumber
     */
    public String getTelephoneNumber() {
        return telephoneNumber;
    }

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

    public String toString() {
        return "Users{username = " + username + ", password = " + password + ", identifyNumber = " + identifyNumber + ", telephoneNumber = " + telephoneNumber + "}";
    }
}

5.构造方法

1.注册功能

注册功能相对于其他几个功能来说是最复杂的，需要使用4个板块，那么就需要写4个验证方法。同时在这个方法中调用了提供随机验证码这个方法。这个是我自己加的，需求只要求在登录操作中增加，我觉得加了之后会变得更有趣，更真实。

//注册
public static void register(ArrayList<Users> list){
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入用户名:");
    while (true) {
        String username = sc.next();
        //开发细节：先验证格式是否正确，再验证是否唯一
        //因为在以后所有的数据，都是存在数据库中，如果我们要校验，需要使用到网络资源。
    
        //调用方法，判断用户名格式是否正确
        String lastUserName = verifyUserName(username);
        //用户名格式正确后，再判断该用户名是否唯一
        boolean flag = contains(list, username);
        if ( flag ) {
            System.out.println("当前用户名"+username+"已经存在");
            System.out.println("请重新输入:");
        } else {
            //如果得到的正确用户名不为空，则进行下一步
            if(lastUserName != null){
                //调用方法，验证密码
                String lastPassword = verifyPassword();
                //如果得到的正确密码不为空，则进行下一步
                if(lastPassword != null){
                    //调用方法，验证身份证号码格式是否正确
                    String lastIdentifyNumber = verifyIdentifyNumber();
                    //如果得到的身份证号码不为空，则进行下一步
                    if(lastIdentifyNumber != null){
                        //调用方法，验证手机号格式是否正确
                        String lastTelephoneNumber = verifyTelephoneNumber();
                        //如果得到的身份证号码不为空，则添加新用户到集合中
                        if(lastTelephoneNumber != null) {
                            while (true) {
                                String rightCode = getCode();
                                System.out.println("注册验证码为:" + rightCode);
                                System.out.println("请输入验证码:");
                                String code = sc.next();
                                if (rightCode.equalsIgnoreCase(code)) {
                                    System.out.println("验证码正确");
                                    break;
                                } else {
                                    System.out.println("验证码错误");
                                    continue;
                                }
                            }
                            list.add(new Users(lastUserName,lastPassword,lastIdentifyNumber,lastTelephoneNumber));
                            System.out.println("注册成功！");
                            break;
                        }
                    }
                }
            }
        }
    }
}

1.用户名格式验证

最后得到了正确的用户名，我们将返回这个正确的用户名，所以方法类型为String。

//验证用户名的格式
public static String verifyUserName(String username){
    //定义一个计数器，便于后面记录字符的数量
    int count = 0;
    int length = username.length();
    String lastUserName = null;//初始化，用来存储格式正确的用户名
    loop:
    while (true) {
        //如果用户名长度在3~15之间，则验证下一步。否则提示用户
        if ( length>=3 && length<=15 ) {
            //遍历用户名长度
            for (int i = 0; i < username.length(); i++) {
                //i 索引
                //得到每一个字符
                char character = username.charAt(i);
                //判断每一个字符类型
                if((character>='a'&&character<='z')||(character>='A' && character<='Z')||(character>='0'&&character<='9')){
                    if ((character>='a'&& character<='z')||(character>='A' && character<='Z')){
                        //如果用户名中出现了一个字符那么count就+1
                        count++;
                    }
                    if(count>0){
                        //只要找到了一个字符，就说明这个用户名可用，那么直接赋值后break
                        lastUserName = username;
                        break loop;
                    } else {
                        System.out.println("您输入的用户名不符合条件，请重新输入:");
                        break loop;
                    }
                } else {
                    System.out.println("您输入的用户名不符合条件，请重新输入:");
                    break loop;
                }
            }
        } else {
            System.out.println("用户名长度必须在3~15个字符之间，请重新出入:");
        }
    }
    return lastUserName;
}

2.密码验证

这个方法是最简单的，只需要比较前后输入的密码是否一致即可。

//验证密码是否前后一致
public static String verifyPassword(){
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入密码:");
    String password = sc.next();
    System.out.println("请再次输入密码:");
    String lastPassword = null;//初始化，用来存储正确的密码
    while (true) {
        String ConfirmPassword = sc.next();
        //用equals方法判断前后密码是否一致
        if(password.equals(ConfirmPassword)){
            lastPassword = password;
             break;
        } else {
            System.out.println("密码不一致，请重新输入:");
        }
    }
    return lastPassword;
}

3.身份证号码格式验证

这个验证就比较复杂了，需要根据需求，验证身份证号码每一位的字符情况。

//验证身份证号码的格式
public static String verifyIdentifyNumber(){
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入身份证号码:");
    String lastIdentifyNumber = null;//初始化，用来存储格式正确的身份证号码
    loop:
    while (true) {
        String identifyNumber = sc.next();
        int length = identifyNumber.length();
        //如果身份证号码长度为18位，则验证下一步。否则提示用户
        if(length == 18){
            //如果身份证号码的0索引，第一个数字不等于0，那么验证下一步。否则提示用户
            if(identifyNumber.charAt(0)!='0'){
                //判断身份证号码前17位是否都为数字，是的话验证下一步。否则提示用户
                for (int i = 0; i < identifyNumber.length()-1; i++) {
                    char character = identifyNumber.charAt(i);
                    if(!(character>='0'&&character<='9')){
                        System.out.println("您输入的身份证号码有误，请重新输入:");
                        break loop;
                    }
                }
                //判断身份证号码最后一位是否为数字或大写X或小写x，是的话赋值。否则提示用户
                if((identifyNumber.charAt(identifyNumber.length()-1)>='0'&&identifyNumber.charAt(identifyNumber.length()-1)<='9')||
                        (identifyNumber.charAt(identifyNumber.length()-1)=='X')||(identifyNumber.charAt(identifyNumber.length()-1)=='x')) {
                    lastIdentifyNumber = identifyNumber;
                } else {
                    System.out.println("您输入的身份证号码有误，请重新输入:");
                }

            } else {
                System.out.println("您输入的身份证号码有误，请重新输入:");
            }
        } else {
            System.out.println("您输入的身份证号码不符合要求，请重新输入:");
        }
    }

    return lastIdentifyNumber;
}

4.手机号码格式验证

这个方法的复杂程度比身份证号码格式验证的小，但是还是比较复杂，需要耐心看需求耐心写。

//验证手机号码的格式
public static String verifyTelephoneNumber(){
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入手机号:");
    String lastTelephoneNumber = null;//初始化，用来存储格式正确的手机号码
    loop:
    while (true) {
        String telephoneNumber = sc.next();
        int length = telephoneNumber.length();
        //如果手机号长度为11位，那么验证下一步。否则提示用户
        if(length == 11){
            //如果手机号的0索引，第一个数字不等于0，那么验证下一步。否则提示用户
            if(telephoneNumber.charAt(0) != '0'){
                //遍历手机号长度
                for (int i = 0; i < telephoneNumber.length(); i++) {
                    //得到每一个字符
                    char character = telephoneNumber.charAt(i);
                    //如果每一位都是数字则赋值
                    if(character>='0'&&character<='9'){
                        lastTelephoneNumber = telephoneNumber;
                    } else {
                        System.out.println("您输入的手机号有误，请重新输入:");
                        break loop;
                    }
                }
            } else {
                System.out.println("您输入的手机号有误，请重新输入:");
            }
        } else {
            System.out.println("您输入的手机号不符合要求，请重新输入:");
        }
    }
    return lastTelephoneNumber;
}

2.登录功能

登录功能比较简单，就是写随机验证码的时候思维要求比较高，过程较复杂。这里面用到了一个封装的思想：可以把一些零散的数据，封装成一个对象，以后传递参数的时候，只要传递一个整体就可以了，不需要管这些零散的数据。

在登录成功后，我们就可以创建上一篇文章学生管理系统的对象，然后调用方法，这样就能继续在这个程序中使用到学生管理系统的功能了，但需要注意的是，学生管理系统需要跟着做一点修改，修改它的主方法名字，从main改为startStudentSystem。

public static void startStudentSystem(){

···

}

//登录
public static void login(ArrayList<Users> list){
    Scanner sc = new Scanner(System.in);
    //判断用户名和密码是否正确一共有三次机会，则循环三次
    for (int i = 0; i < 3; i++) {
        System.out.println("请输入用户名:");
        String username = sc.next();
        //判断用户名是否已经注册
        boolean flag = contains(list, username);
        if (!flag) {//取反使代码更简洁
            System.out.println("您输入的用户名" + username + "未注册，请先注册");
            return;//未注册直接结束方法
        }
        System.out.println("请输入密码:");
        String password = sc.next();
        while (true) {
            String rightCode = getCode();
            System.out.println("登录验证码为:" + rightCode);
            System.out.println("请输入验证码:");
            String code = sc.next();
            if(rightCode.equalsIgnoreCase(code)){
                System.out.println("验证码正确");
                break;
            } else {
                System.out.println("验证码错误");
                continue;
            }
        }
        //验证用户名和密码是否正确
        //集合中是否包含当前的用户名和密码
        //定义一个方法验证用户名和密码是否正确

        //封装思想的应用：
        //可以把一些零散的数据，封装成一个对象
        //以后传递参数的时候，只要传递一个整体就可以了，不需要管这些零散的数据。
        Users useInfo = new Users(username, password, null, null);
        boolean result = verifyUserInfo(list, useInfo);
        if (result) {
            System.out.println("登陆成功，可以开始使用猴王学生管理系统了");
            //创建对象调用方法，启动学生管理系统
            StudentSystem ss = new StudentSystem();
            ss.startStudentSystem();
            break;
        } else {
            System.out.println("登陆失败，用户名或密码错误");
            if (i == 2) {
                System.out.println("当前帐号" + username + "被锁定，请联系猴王学生管理系统—管理端客服：18190967582");
                //当前账号锁定之后，直接结束方法即可
                return;
            } else {
                System.out.println("用户名或密码错误，还剩下" + (2 - i) + "次机会");
            }
        }
    }
}

1.验证输入的用户名和密码能否在集合中找到

//判断登录时输入的用户名和密码能否在集合中找到
public static boolean verifyUserInfo(ArrayList<Users> list, Users useInfo) {
    //遍历集合，判断用户是否存在，如果存在登陆成功，如果不存在登录失败
    for (int i = 0; i < list.size(); i++) {
        Users user = list.get(i);
        if (user.getUsername().equals(useInfo.getUsername()) && user.getPassword().equals(useInfo.getPassword())) {
            return true;
        }
    }
    return false;
}

3.忘记密码

该方法比较简单，但值得注意的是修改密码的时候是直接用Users类里面的setter方法。

//忘记密码
public static void forgetPassword(ArrayList<Users> list){
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入用户名:");
    String username = sc.next();
    boolean flag = contains(list, username);
    if(!flag){
        System.out.println("该用户名"+username+"未注册");
        return;
    }
    System.out.println("请输入身份证号码:");
    String identifyNumber = sc.next();
    System.out.println("请输入手机号码:");
    String telephoneNumber = sc.next();
    //要比较用户对象中的手机号码和身份证号码是否相同
    //需要把用户对象通过索引先获取出来。
    int index = getIndex(list,username);
    Users user = list.get(index);
    //然后就可以比较用户对象中的手机号码和身份证号码是否相同
    if(!(user.getIdentifyNumber().equals(identifyNumber) && user.getTelephoneNumber().equals(telephoneNumber))){
        System.out.println("身份证号码或手机号码输入有误，不能修改密码");
        return;
    }//取反，使代码更简洁

    //当代码执行到这里，表示所有的数据全部验证成功，直接修改即可
    String password;
    while (true) {
        System.out.println("请输入新的密码:");
        password = sc.next();
        System.out.println("请再次输入新的密码:");
        String againPassword = sc.next();
        while (true) {
            String rightCode = getCode();
            System.out.println("修改密码验证码为:" + rightCode);
            System.out.println("请输入验证码:");
            String code = sc.next();
            if (rightCode.equalsIgnoreCase(code)) {
                System.out.println("验证码正确");
                break;
            } else {
                System.out.println("验证码错误");
                continue;
            }
        }
        if(password.equals(againPassword)){
            System.out.println("两次密码输入一致");
            break;
        } else {
            System.out.println("两次密码输入不一致，请重新输入");
            continue;
        }
    }

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

}

4.查询功能

这个方法是需求中没有的，也是我自己添加的。

//查询管理员
public static void queryUser(ArrayList<Users> list) {
    if (list.isEmpty()) {    // if ( list.size() == 0 ) {
        System.out.println("当前无管理员信息，请添加后再查询");
        //结束方法
        return;
    }

    //打印表头
    //\t和空格是为了查询时数据对齐，更好看
    System.out.println("用户名\t密码\t\t身份证号码\t\t\t  手机号码");
    //当代码执行到这里，表示集合中是有数据的
    for (int i = 0; i < list.size(); i++) {
        Users u = list.get(i);
        //\t和空格是为了查询时数据对齐，更好看
        System.out.println(u.getUsername() + "\t" + u.getPassword() + "\t" + u.getIdentifyNumber() + "\t  " + u.getTelephoneNumber());
    }
}

5.getIndex方法

这个方法在上一篇文章当中已经详细讲过了，这里是类似的用法。

//通过username获取索引的方法
public static int getIndex(ArrayList<Users> list,String userName) {
    //遍历集合
    for (int i = 0; i < list.size(); i++) {
        //得到每一个用户对象
        Users u = list.get(i);
        //得到每一个用户对象的name
        String name = u.getUsername();
        //拿着集合中的用户name跟要查询的userName进行比较
        if (name.equals(userName)){
            //如果一样，那么就返回索引
            return i;
        }
    }
    //当循环结束之后还没有找到，就表示不存在，返回-1.
    return -1;
}

6.contains方法

这个方法在上一篇文章当中已经详细讲过了，这里是类似的用法。

//判断username在集合中是否存在
public static boolean contains(ArrayList<Users> list,String userName) {
    //循环遍历集合得到里面的每一个学生对象
    for (int i = 0; i < list.size(); i++) {
        //拿到用户对象后，获取userName并进行判断
        Users u  = list.get(i);
        String name = u.getUsername();
        if (name.equals(userName)){
            //存在，true
            return true;
        }
    }
    //不存在 false
    return false;
    //return getIndex(list,userName) >= 0;   // 直接调用方法，提高复用性。
}

7.生成一个随机验证码

随机，这个词相信大家都能想到这里要使用Random类。这里我们还用到了StringBuilder和链式编程的知识。

//生成一个验证码
public static String getCode() {
    //1.创建一个集合添加所有的大写和小写字母
    ArrayList<Character> list = new ArrayList<>();
    for (int i = 0; i < 26; i++) {
        list.add((char) ('a' + i));
        list.add((char) ('A' + i));
    }

    StringBuilder sb = new StringBuilder();
    //2.要随机抽取4个字符
    Random r = new Random();
    for (int i = 0; i < 4; i++) {
        //获取随机索引
        int index = r.nextInt(list.size());
        //利用随机索引获取随机字符
        char c = list.get(index);
        //把随机字符添加到sb当中
        sb.append(c);
    }

    //3.把一个随机数字添加到末尾
    int number = r.nextInt(10);
    sb.append(number);  //但是现在数字不是出现在任意位置

    //4.如果要修改字符串中的内容
    //先把字符串变成字符数组，在数组中修改，然后再创建一个新的字符串
    char[] arr = sb.toString().toCharArray();
    //拿着最后一个索引，跟随机索引进行交换
    int randomIndex = r.nextInt(arr.length);
    //最大索引指向的元素，跟随机索引指向的元素交换
    char temp = arr[randomIndex];
    arr[randomIndex] = arr[arr.length - 1];
    arr[arr.length - 1] = temp;

    return new String(arr);

}

6.主方法

这里和上一篇文章类似，用了增强switch。

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    loop:
    while (true) {
        System.out.println("欢迎来到猴王学生管理系统—管理员端");
        System.out.println("请选择操作1登录 2注册 3忘记密码 4查询管理员信息 5退出");
        String choose = sc.next();
        switch (choose){
            case LOGIN -> login(list);
            case REGISTER -> register(list);
            case FORGETPASSWORD -> forgetPassword(list);
            case QUERY -> queryUser(list);
            case EXIT -> {
                System.out.println("谢谢使用，再见");
                //break loop;
                System.exit(0);
            }
            default -> {
                System.out.println("没有这个选项，请重新选择");
                break loop;
            }
        }
    }
}

7.静态代码块

这里的使用主要是提前在集合中存储一个管理员信息。

//在方法外面类里面用static修饰集合，便于后面静态代码块的使用
static ArrayList<Users> list = new ArrayList<>();
static {
    list.add(new Users("MonKing","1234qwer","110101200001011234","18190967582"));
}

8.final的使用

这里的使用主要就是和主方法中的增强switch中的case结合起来，使代码可读性更高。

public static final String LOGIN = "1";
public static final String REGISTER = "2";
public static final String FORGETPASSWORD = "3";
public static final String QUERY = "4";
public static final String EXIT = "5";

9.完整代码

import java.util.*;

public class UpdateStudentSystem {
    public static final String LOGIN = "1";
    public static final String REGISTER = "2";
    public static final String FORGETPASSWORD = "3";
    public static final String QUERY = "4";
    public static final String EXIT = "5";

    //在方法外面类里面用static修饰集合，便于后面静态代码块的使用
    static ArrayList<Users> list = new ArrayList<>();
    static {
        list.add(new Users("MonKing","1234qwer","110101200001011234","18190967582"));
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        loop:
        while (true) {
            System.out.println("欢迎来到猴王学生管理系统—管理员端");
            System.out.println("请选择操作1登录 2注册 3忘记密码 4查询管理员信息 5退出");
            String choose = sc.next();
            switch (choose){
                case LOGIN -> login(list);
                case REGISTER -> register(list);
                case FORGETPASSWORD -> forgetPassword(list);
                case QUERY -> queryUser(list);
                case EXIT -> {
                    System.out.println("谢谢使用，再见");
                    //break loop;
                    System.exit(0);
                }
                default -> {
                    System.out.println("没有这个选项，请重新选择");
                    break loop;
                }
            }
        }
    }

    //登录
    public static void login(ArrayList<Users> list){
        Scanner sc = new Scanner(System.in);
        //判断用户名和密码是否正确一共有三次机会，则循环三次
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入用户名:");
            String username = sc.next();
            //判断用户名是否已经注册
            boolean flag = contains(list, username);
            if (!flag) {//取反使代码更简洁
                System.out.println("您输入的用户名" + username + "未注册，请先注册");
                return;//未注册直接结束方法
            }
            System.out.println("请输入密码:");
            String password = sc.next();
            while (true) {
                String rightCode = getCode();
                System.out.println("登录验证码为:" + rightCode);
                System.out.println("请输入验证码:");
                String code = sc.next();
                if(rightCode.equalsIgnoreCase(code)){
                    System.out.println("验证码正确");
                    break;
                } else {
                    System.out.println("验证码错误");
                    continue;
                }
            }
            //验证用户名和密码是否正确
            //集合中是否包含当前的用户名和密码
            //定义一个方法验证用户名和密码是否正确

            //封装思想的应用：
            //可以把一些零散的数据，封装成一个对象
            //以后传递参数的时候，只要传递一个整体就可以了，不需要管这些零散的数据。
            Users useInfo = new Users(username, password, null, null);
            boolean result = verifyUserInfo(list, useInfo);
            if (result) {
                System.out.println("登陆成功，可以开始使用猴王学生管理系统了");
                //创建对象调用方法，启动学生管理系统
                StudentSystem ss = new StudentSystem();
                ss.startStudentSystem();
                break;
            } else {
                System.out.println("登陆失败，用户名或密码错误");
                if (i == 2) {
                    System.out.println("当前帐号" + username + "被锁定，请联系猴王学生管理系统—管理端客服：18190967582");
                    //当前账号锁定之后，直接结束方法即可
                    return;
                } else {
                    System.out.println("用户名或密码错误，还剩下" + (2 - i) + "次机会");
                }
            }
        }
    }

    //注册
    public static void register(ArrayList<Users> list){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名:");
        while (true) {
            String username = sc.next();
            //开发细节：先验证格式是否正确，再验证是否唯一
            //因为在以后所有的数据，都是存在数据库中，如果我们要校验，需要使用到网络资源。

            //调用方法，判断用户名格式是否正确
            String lastUserName = verifyUserName(username);
            //用户名格式正确后，再判断该用户名是否唯一
            boolean flag = contains(list, username);
            if ( flag ) {
                System.out.println("当前用户名"+username+"已经存在");
                System.out.println("请重新输入:");
            } else {
                //如果得到的正确用户名不为空，则进行下一步
                if(lastUserName != null){
                    //调用方法，验证密码
                    String lastPassword = verifyPassword();
                    //如果得到的正确密码不为空，则进行下一步
                    if(lastPassword != null){
                        //调用方法，验证身份证号码格式是否正确
                        String lastIdentifyNumber = verifyIdentifyNumber();
                        //如果得到的身份证号码不为空，则进行下一步
                        if(lastIdentifyNumber != null){
                            //调用方法，验证手机号格式是否正确
                            String lastTelephoneNumber = verifyTelephoneNumber();
                            //如果得到的身份证号码不为空，则添加新用户到集合中
                            if(lastTelephoneNumber != null) {
                                while (true) {
                                    String rightCode = getCode();
                                    System.out.println("注册验证码为:" + rightCode);
                                    System.out.println("请输入验证码:");
                                    String code = sc.next();
                                    if (rightCode.equalsIgnoreCase(code)) {
                                        System.out.println("验证码正确");
                                        break;
                                    } else {
                                        System.out.println("验证码错误");
                                        continue;
                                    }
                                }
                                list.add(new Users(lastUserName,lastPassword,lastIdentifyNumber,lastTelephoneNumber));
                                System.out.println("注册成功！");
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    //忘记密码
    public static void forgetPassword(ArrayList<Users> list){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名:");
        String username = sc.next();
        boolean flag = contains(list, username);
        if(!flag){
            System.out.println("该用户名"+username+"未注册");
            return;
        }
        System.out.println("请输入身份证号码:");
        String identifyNumber = sc.next();
        System.out.println("请输入手机号码:");
        String telephoneNumber = sc.next();
        //要比较用户对象中的手机号码和身份证号码是否相同
        //需要把用户对象通过索引先获取出来。
        int index = getIndex(list,username);
        Users user = list.get(index);
        //然后就可以比较用户对象中的手机号码和身份证号码是否相同
        if(!(user.getIdentifyNumber().equals(identifyNumber) && user.getTelephoneNumber().equals(telephoneNumber))){
            System.out.println("身份证号码或手机号码输入有误，不能修改密码");
            return;
        }//取反，使代码更简洁

        //当代码执行到这里，表示所有的数据全部验证成功，直接修改即可
        String password;
        while (true) {
            System.out.println("请输入新的密码:");
            password = sc.next();
            System.out.println("请再次输入新的密码:");
            String againPassword = sc.next();
            while (true) {
                String rightCode = getCode();
                System.out.println("修改密码验证码为:" + rightCode);
                System.out.println("请输入验证码:");
                String code = sc.next();
                if (rightCode.equalsIgnoreCase(code)) {
                    System.out.println("验证码正确");
                    break;
                } else {
                    System.out.println("验证码错误");
                    continue;
                }
            }
            if(password.equals(againPassword)){
                System.out.println("两次密码输入一致");
                break;
            } else {
                System.out.println("两次密码输入不一致，请重新输入");
                continue;
            }
        }

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

    }

    //查询管理员
    public static void queryUser(ArrayList<Users> list) {
        if (list.isEmpty()) {    // if ( list.size() == 0 ) {
            System.out.println("当前无管理员信息，请添加后再查询");
            //结束方法
            return;
        }

        //打印表头
        //\t和空格是为了查询时数据对齐，更好看
        System.out.println("用户名\t密码\t\t身份证号码\t\t\t  手机号码");
        //当代码执行到这里，表示集合中是有数据的
        for (int i = 0; i < list.size(); i++) {
            Users u = list.get(i);
            //\t和空格是为了查询时数据对齐，更好看
            System.out.println(u.getUsername() + "\t" + u.getPassword() + "\t" + u.getIdentifyNumber() + "\t  " + u.getTelephoneNumber());
        }
    }


    //判断登录时输入的用户名和密码能否在集合中找到
    public static boolean verifyUserInfo(ArrayList<Users> list, Users useInfo) {
        //遍历集合，判断用户是否存在，如果存在登陆成功，如果不存在登录失败
        for (int i = 0; i < list.size(); i++) {
            Users user = list.get(i);
            if (user.getUsername().equals(useInfo.getUsername()) && user.getPassword().equals(useInfo.getPassword())) {
                return true;
            }
        }
        return false;
    }

    //验证用户名的格式
    public static String verifyUserName(String username){
        //定义一个计数器，便于后面记录字符的数量
        int count = 0;
        int length = username.length();
        String lastUserName = null;//初始化，用来存储格式正确的用户名
        loop:
        while (true) {
            //如果用户名长度在3~15之间，则验证下一步。否则提示用户
            if ( length>=3 && length<=15 ) {
                //遍历用户名长度
                for (int i = 0; i < username.length(); i++) {
                    //i 索引
                    //得到每一个字符
                    char character = username.charAt(i);
                    //判断每一个字符类型
                    if((character>='a'&&character<='z')||(character>='A' && character<='Z')||(character>='0'&&character<='9')){
                        if ((character>='a'&& character<='z')||(character>='A' && character<='Z')){
                            //如果用户名中出现了一个字符那么count就+1
                            count++;
                        }
                        if(count>0){
                            //只要找到了一个字符，就说明这个用户名可用，那么直接赋值后break
                            lastUserName = username;
                            break loop;
                        } else {
                            System.out.println("您输入的用户名不符合条件，请重新输入:");
                            break loop;
                        }
                    } else {
                        System.out.println("您输入的用户名不符合条件，请重新输入:");
                        break loop;
                    }
                }
            } else {
                System.out.println("用户名长度必须在3~15个字符之间，请重新出入:");
            }
        }
        return lastUserName;
    }

    //验证密码是否前后一致
    public static String verifyPassword(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入密码:");
        String password = sc.next();
        System.out.println("请再次输入密码:");
        String lastPassword = null;//初始化，用来存储正确的密码
        while (true) {
            String ConfirmPassword = sc.next();
            //用equals方法判断前后密码是否一致
            if(password.equals(ConfirmPassword)){
                lastPassword = password;
                 break;
            } else {
                System.out.println("密码不一致，请重新输入:");
            }
        }
        return lastPassword;
    }

    //验证身份证号码的格式
    public static String verifyIdentifyNumber(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入身份证号码:");
        String lastIdentifyNumber = null;//初始化，用来存储格式正确的身份证号码
        loop:
        while (true) {
            String identifyNumber = sc.next();
            int length = identifyNumber.length();
            //如果身份证号码长度为18位，则验证下一步。否则提示用户
            if(length == 18){
                //如果身份证号码的0索引，第一个数字不等于0，那么验证下一步。否则提示用户
                if(identifyNumber.charAt(0)!='0'){
                    //判断身份证号码前17位是否都为数字，是的话验证下一步。否则提示用户
                    for (int i = 0; i < identifyNumber.length()-1; i++) {
                        char character = identifyNumber.charAt(i);
                        if(!(character>='0'&&character<='9')){
                            System.out.println("您输入的身份证号码有误，请重新输入:");
                            break loop;
                        }
                    }
                    //判断身份证号码最后一位是否为数字或大写X或小写x，是的话赋值。否则提示用户
                    if((identifyNumber.charAt(identifyNumber.length()-1)>='0'&&identifyNumber.charAt(identifyNumber.length()-1)<='9')||
                            (identifyNumber.charAt(identifyNumber.length()-1)=='X')||(identifyNumber.charAt(identifyNumber.length()-1)=='x')) {
                        lastIdentifyNumber = identifyNumber;
                    } else {
                        System.out.println("您输入的身份证号码有误，请重新输入:");
                    }

                } else {
                    System.out.println("您输入的身份证号码有误，请重新输入:");
                }
            } else {
                System.out.println("您输入的身份证号码不符合要求，请重新输入:");
            }
        }

        return lastIdentifyNumber;
    }

    //验证手机号码的格式
    public static String verifyTelephoneNumber(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号:");
        String lastTelephoneNumber = null;//初始化，用来存储格式正确的手机号码
        loop:
        while (true) {
            String telephoneNumber = sc.next();
            int length = telephoneNumber.length();
            //如果手机号长度为11位，那么验证下一步。否则提示用户
            if(length == 11){
                //如果手机号的0索引，第一个数字不等于0，那么验证下一步。否则提示用户
                if(telephoneNumber.charAt(0) != '0'){
                    //遍历手机号长度
                    for (int i = 0; i < telephoneNumber.length(); i++) {
                        //得到每一个字符
                        char character = telephoneNumber.charAt(i);
                        //如果每一位都是数字则赋值
                        if(character>='0'&&character<='9'){
                            lastTelephoneNumber = telephoneNumber;
                        } else {
                            System.out.println("您输入的手机号有误，请重新输入:");
                            break loop;
                        }
                    }
                } else {
                    System.out.println("您输入的手机号有误，请重新输入:");
                }
            } else {
                System.out.println("您输入的手机号不符合要求，请重新输入:");
            }
        }
        return lastTelephoneNumber;
    }

    //判断username在集合中是否存在
    public static boolean contains(ArrayList<Users> list,String userName) {
        //循环遍历集合得到里面的每一个学生对象
        for (int i = 0; i < list.size(); i++) {
            //拿到用户对象后，获取userName并进行判断
            Users u  = list.get(i);
            String name = u.getUsername();
            if (name.equals(userName)){
                //存在，true
                return true;
            }
        }
        //不存在 false
        return false;
        //return getIndex(list,userName) >= 0;   // 直接调用方法，提高复用性。
    }

    //通过username获取索引的方法
    public static int getIndex(ArrayList<Users> list,String userName) {
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            //得到每一个用户对象
            Users u = list.get(i);
            //得到每一个用户对象的name
            String name = u.getUsername();
            //拿着集合中的用户name跟要查询的userName进行比较
            if (name.equals(userName)){
                //如果一样，那么就返回索引
                return i;
            }
        }
        //当循环结束之后还没有找到，就表示不存在，返回-1.
        return -1;
    }

    //生成一个验证码
    public static String getCode() {
        //1.创建一个集合添加所有的大写和小写字母
        ArrayList<Character> list = new ArrayList<>();
        for (int i = 0; i < 26; i++) {
            list.add((char) ('a' + i));
            list.add((char) ('A' + i));
        }

        StringBuilder sb = new StringBuilder();
        //2.要随机抽取4个字符
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            //获取随机索引
            int index = r.nextInt(list.size());
            //利用随机索引获取随机字符
            char c = list.get(index);
            //把随机字符添加到sb当中
            sb.append(c);
        }

        //3.把一个随机数字添加到末尾
        int number = r.nextInt(10);
        sb.append(number);  //但是现在数字不是出现在任意位置

        //4.如果要修改字符串中的内容
        //先把字符串变成字符数组，在数组中修改，然后再创建一个新的字符串
        char[] arr = sb.toString().toCharArray();
        //拿着最后一个索引，跟随机索引进行交换
        int randomIndex = r.nextInt(arr.length);
        //最大索引指向的元素，跟随机索引指向的元素交换
        char temp = arr[randomIndex];
        arr[randomIndex] = arr[arr.length - 1];
        arr[arr.length - 1] = temp;

        return new String(arr);

    }
}

10.分析

这个项目其实有很多地方和上一篇文章中的代码有相似之处，也比较简单。大家如果能自己写出来这个项目，就说明大家Java的基础已经非常扎实了。这个学生管理系统学生端和管理员端结合起来，就是平常大家经常看到的网上的完整的学生管理系统。通过书写此项目也能提高自己对项目书写的逻辑思维。（不同于算法的思维）

本篇文章到此结束，谢谢大家的观看

MonKingProgrammer

关注

27
点赞
踩
24

收藏

觉得还不错? 一键收藏
打赏
3
评论
Java—简单的控制台版学生管理系统（管理员登录端）（内附完整代码）

这个学生管理系统学生端和管理员端结合起来，就是平常大家经常看到的网上的完整的学生管理系统。在登录成功后，我们就可以创建上一篇文章学生管理系统的对象，然后调用方法，这样就能继续在这个程序中使用到学生管理系统的功能了，但需要注意的是，学生管理系统需要跟着做一点修改，修改它的主方法名字，从。这个方法的复杂程度比身份证号码格式验证的小，但是还是比较复杂，需要耐心看需求耐心写。最后得到了正确的用户名，我们将返回这个正确的用户名，所以方法类型为。这个方法是需求中没有的，也是我自己添加的。这里和上一篇文章类似，用了。
复制链接

扫一扫