代码实操2

• 11.16下午7点
• 添加注册功能

import javax.naming.OperationNotSupportedException;
import java.util.ArrayList;
import java.util.Scanner;

public class useTest {
    public static void main(String[] args) {
        //创建用户类
        use use = new use();
        //集合记录用户名
        ArrayList<String> Aname = new ArrayList<>();
        //集合记录密码
        ArrayList<String> Apassword = new ArrayList<>();
        //集合记录身份证号码
        ArrayList<String> Acard = new ArrayList<>();
        //集合记录手机号码
        ArrayList<String> Aphone = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        //主界面
        while (true) {
            System.out.println("欢迎来到学生管理系统");
            System.out.println("请选择操作1登录 2注册 3忘记密码 4退出");
            int i = sc.nextInt();
            switch (i) {
                case 1 -> System.out.println("登陆");
                case 2 -> Username(Aname,Apassword, Acard, Aphone);
                case 3 -> System.out.println("忘记密码");
                case 4 -> System.exit(0);
                default -> System.out.println("没有此选项");
            }
        }

    }
    public static void Username(ArrayList<String> Aname, ArrayList<String> Apassword, ArrayList<String> Acard, ArrayList<String> Aphone) {
        Scanner sc = new Scanner(System.in);
        //注册用户名
        while (true) {
            //键盘录入用户名
            int a = 0;
            System.out.println("请输入用户名");
            String name = sc.nextLine();
            //调用方法判断长度
            boolean length = length(name);
            //调用方法判断是否重复
            boolean repeat = repeat(Aname, name);
            //调用方法判断是否包含标点符号
            boolean combination1 = combination1(name);
            //
            boolean combination2 = combination2(name);
            //判断长度
            if (length) {
                System.out.println("用户名长度不符合要求,请重新输入");
            } else if (repeat) {
                System.out.println("用户名重复，请重新输入");
            } else if (combination1) {
                System.out.println("用户名不能包含标点符号等，请重新输入");
            } else if (combination2) {
                System.out.println("用户名不能为纯数字，请重新输入");
            } else {
                System.out.println("用户名输入正确");
                Aname.add(name);
                break;
            }
        }
        //注册密码
        while (true) {
            //键盘录入密码
            System.out.println("请输入密码");
            //输入第一遍密码
            String password1 = sc.next();
            System.out.println("请再次输入密码");
            //输入第二遍密码
            String password2 = sc.next();
            //将两次密码对比，一样的话提示密码注册成功，如果不一样就重新输入
            if (password1.equals(password2)) {
                System.out.println("密码注册成功");
                Apassword.add(password1);
                break;
            } else {
                System.out.println("两次输入的密码不同，请重新输入");
            }
        }
        //注册身份证号
        while (true) {
            System.out.println("请输入身份证号码");
            //键盘录入身份证号码
            String card = sc.next();
            //判断身份证的长度的是否为18，不是为true，是为false
            boolean b = card.length() != 18;
            //判断身份证的第一位是否为0，不是为true，是为false
            boolean b1 = card.charAt(0) != '0';
            //调用方法判断前17位是否为纯数字
            boolean num = num(card);
            //判断最后一位是否在0~9，x，X的范围内
            boolean last = last(card);
            if (b) {
                System.out.println("身份证长度错误，请重新输入");
            } else if (!b1) {
                System.out.println("身份证第一位格式错误，请重新输入");
            } else if (num) {
                System.out.println("身份证前17位格式错误，请重新输入");
            } else if (last) {
                System.out.println("身份证最后一位格式错误，请重新输入");
            } else {
                System.out.println("身份证录入成功！");
                Acard.add(card);
                break;
            }

        }
        //注册手机号
        while (true) {
            //键盘录入手机号
            System.out.println("请输入你的手机号码");
            String phone = sc.next();
            boolean b = phone.length() != 11;//相等为false，不相等为true
            boolean b1 = phone.charAt(0) != '0';//相等为false，不相等为true
            boolean digital = digital(phone);
            if (b) {
                System.out.println("手机号长度输入错误，请重新输入");
            } else if (!b1) {
                System.out.println("手机号第一位不能为0，请重新输入");
            } else if (digital) {
                System.out.println("手机号只能为纯数字");
            } else {
                System.out.println("手机号验证成功");
                Aphone.add(phone);
                break;
            }
        }
        System.out.println("账号注册成功！！！");
        System.out.println("请记住您的账户密码！！！");
    }


    //判断用户名的长度是否符合要求
    public static boolean length(String name) {
        if (name.length() > 15 || name.length() < 3) {
            return true;
        }
        return false;
    }

    //判断用户名是否存在  repeat-重复
    public static boolean repeat(ArrayList<String> Aname, String name) {
        //利用循环遍历用户名集合判断用户名是否重复
        for (int i = 0; i < Aname.size(); i++) {
            boolean panduan = Aname.get(i).equals(name);
            if (panduan) {
                System.out.println("用户名重复，请重新输入");
                return true;
            }
        }
        return false;
    }

    //判断用户名的组合是否正确 组合=combination
    public static boolean combination1(String name) {
        //创建一个数组用来记录数字和字母，然后遍历和输入的用户名进行对比
        //如果用户名里有一个在数组中不存在，那么就输入错误,需要重新输入
        char[] zmsz = new char[62];
        char a = 'a' - 1;
        char A = 'A' - 1;
        char num = '0' - 1;
        //将需要的数据添加到数组中
        for (int i = 0; i < zmsz.length; i++) {
            if (i > 51) {
                num++;
                zmsz[i] = num;
            } else if (i > 25) {
                A++;
                zmsz[i] = A;
            } else {
                a++;
                zmsz[i] = a;
            }
        }
        //将数组装换成字符串
        String s = "";
        for (int i = 0; i < zmsz.length; i++) {
            s = s + zmsz[i] + "";
        }
        //利用循环嵌套，将name里的每一个字符进行对比
        int b;
        boolean equals = true;
        for (int i = 0; i < name.length(); i++) {
            b = 0;
            for (int n = 0; n < zmsz.length; n++) {
                //转换成字符串形式
                String c = name.charAt(i) + "";
                String s1 = s.charAt(n) + "";
                equals = c.equals(s1);
                if (!equals) {
                    //将用户名的每一个字符进行对比
                    //当用户名的字符和数组中的字符不同时，输出false，相同时输出true
                    //当输出false时，b++;
                    //如果字符存在'a'~'b',A~B,0~9中 那么就只会有61个false
                    b++;
                }
                //当b==62时，说明用户名中有字符不符合要求
                if (b == 62) {
                    //如果有不同的，就说明不符合要求，返回true
                    return true;
                }
            }
        }
        //符合要求，返回false
        return false;
    }

    //判断用户名的组合是否为纯数字 组合=combination
    public static boolean combination2(String name) {
        char a = 'a' - 1;
        char A = 'A' - 1;
        char[] zm = new char[52];
        //利用循环将字母的大小写添加到数组中
        for (int i = 0; i < zm.length; i++) {
            if (i > 25) {
                a++;
                zm[i] = a;
            } else {
                A++;
                zm[i] = A;
            }
        }
        //定义一个变量用来记录
        int num1 = 0;
        //先利用循环将name遍历出来，在嵌套zm（字母的大小写）.length的循环
        //将name里面的字符和zm（字母的大小写）数组进行对比
        for (int i = 0; i < name.length(); i++) {
            for (int n = 0; n < zm.length; n++) {
                //将char转换为String
                String sz = zm[n] + "";
                String sn = name.charAt(i) + "";
                //对比 当name字符为字母时，输出true
                //当name字符为数字时，输出false
                boolean equals = sn.equals(sz);
                //当对比结果为true时，num1++
                if (equals) {
                    num1++;
                }
            }
        }
        //当num1为0时，代表用户名为纯数字，返回true
        if (num1 == 0) {
            return true;
        }
        return false;
    }

    //判断身份证前17位是否为纯数字
    public static boolean num(String card) {
        //添加数组用来记录0~9的数字
        char[] num = new char[10];
        char num1 = '0' - 1;
        //利用循环将数字添加到数组中
        for (int i = 0; i < num.length; i++) {
            num1++;
            num[i] = num1;
        }
        //利用循环将身份证的字符遍历出来
        //在嵌套循环将身份证的每一个字符和数字数组对比
        //定义变量用来记录
        for (int i = 0; i < card.length() - 1; i++) {
            int numer = 0;
            for (int n = 0; n < num.length; n++) {
                //对比,相同为true，不同为false
                boolean equals = (card.charAt(i) + "").equals(num[n] + "");
                //当输出为false时，numer++
                if (!equals) {
                    numer++;
                }
            }
            //因为身份证前17位只能是数字（0~9），所以正常来说numer只能等于9
            //当numer等于10时，代表前17位有字母，所以返回true
            if (numer == 10) {
                return true;
            }
        }
        return false;
    }

    //判断身份证的最后一位
    public static boolean last(String card) {
        //添加数组用来记录0~9的数字
        char[] num = new char[12];
        char num1 = '0' - 1;
        char x = 'x';
        char X = 'X';
        //定义变量用来记录
        int numer = 0;
        //利用循环将数字添加到数组中
        for (int i = 0; i < num.length; i++) {
            num1++;
            num[i] = num1;
            if (i == 10) {
                num[i] = x;
            } else if (i == 11) {
                num[i] = X;
            }
        }
        //将身份证最后一位转为字符串
        String s = card.charAt(card.length() - 1) + "";
        //利用循环判断
        for (int i = 0; i < num.length; i++) {
            //将身份证的最后一位拿出来和数组中的值对比，相同为true
            boolean equals = s.equals(num[i] + "");
            //当equals==true时，numer++
            if (equals) {
                numer++;
            }
        }
        //因为身份证只能是0~9和x以及X，所以当格式正确的时候
        //numer==1，当numer==0时表示，输入的身份证最后一位不在0~9，x，X的范围中，返回true
        if (numer == 0) {
            return true;
        } else {
            return false;
        }
    }

    //判断手机号是否都为数字 数字-digital
    public static boolean digital(String phone) {
        //添加数组 记录0~9的数字
        char num = '0' - 1;
        char[] num1 = new char[10];
        //利用循环将数字添加到数组中
        for (int i = 0; i < num1.length; i++) {
            num++;
            num1[i] = num;
        }
        //定义变量记录数据
        int num2 = 0;
        //利用循环将手机号码的字符遍历出来
        //在嵌套循环将手机号的每一个字符和数字数组对比
        for (int i = 0; i < phone.length(); i++) {
            for (int n = 0; n < num1.length; n++) {
                //将字符转换为字符串
                String s = phone.charAt(i) + "";
                String s1 = num1[n] + "";
                //对比，数据相同时为true
                boolean equals = s.equals(s1);
                //当equals的值为true时，num2++
                if (equals) {
                    num2++;
                }
            }
        }
        /*
        对比举例：
        5---1 false     当equals的结果为true时
        5---2 false     num2++
        5---3 false     因为如果手机号是纯数字的话，num2必定加一
        5---4 false     又因为手机号一共有11位
        5---5 true      所以，当num2<11时，表示手机号不是纯数字
        5---6 false     所以返回true
        5---7 false
        5---8 false
        5---9 false
        5---0 false
        */
        if (num2 < 11) {
            return true;
        }
        return false;
    }
}

• 11.17晚上12.35
• 添加登陆功能
• 添加登陆后的界面
• 添加加删改查学生

import javax.naming.OperationNotSupportedException;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class useTest {
    public static void main(String[] args) {
        //创建用户类
        use use = new use();
        //集合记录用户名
        ArrayList<String> Aname = new ArrayList<>();
        //集合记录密码
        ArrayList<String> Apassword = new ArrayList<>();
        //集合记录身份证号码
        ArrayList<String> Acard = new ArrayList<>();
        //集合记录手机号码
        ArrayList<String> Aphone = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        //主界面
        loop:while (true) {
            System.out.println("欢迎来到学生管理系统");
            System.out.println("请选择操作1登录 2注册 3忘记密码 4退出");
            String i = sc.next();
            switch (i) {
                case "1" ->{if (landing(Aname, Apassword)){
                    break loop;
                }
                }
                case "2" -> Username(Aname, Apassword, Acard, Aphone, use);
                case "3" -> System.out.println("忘记密码");
                case "4" -> System.exit(0);
                default -> System.out.println("没有此选项");
            }
        }
        //主菜单
        //创建集合记录学生信息
        ArrayList<Students> as = new ArrayList<>();
        //为外部循环取一个名字，这样就可以指定跳出这个外部循环
        loop:
        while (true) {
            //搭建主界面
            System.out.println("-------------欢迎来到蔡徐坤学院-------------");
            System.out.println("1.添加学生");
            System.out.println("2.删除学生");
            System.out.println("3.修改学生");
            System.out.println("4.查询学生");
            System.out.println("5.退出");
            System.out.println("请输入你的选择");
            //键盘录入用户的选择
            String next = sc.next();
            //识别用户选项并执行
            switch (next) {
                //调用方法添加学生
                case "1" -> add(as);
                case "2" -> delete(as);
                case "3" -> modification(as);
                //调用方法查询学生
                case "4" -> query(as);
                case "5" ->{
                    /*方法1：指定跳出*/
                    break loop;
                    /*方法2
                    System.exit(0);//关闭虚拟机*/
                }
                default -> System.out.println("没有这个选择");
            }
        }
    }

    //登陆
    public static boolean landing(ArrayList<String> Aname, ArrayList<String> Apassword) {
        //定义boolean变量，初始值为false，当a==true时，登陆成功跳转到下一个页面
        boolean a = false;
        Scanner sc = new Scanner(System.in);
        //输入用户名
        System.out.println("请输入用户名");
        String name = sc.next();
        //调用方法将输入的用户名和数据库中的用户名进行对比
        boolean b = validation1(Aname, name);
        if (b) {System.out.println("此用户名还没有注册，请先注册");
        }//调用方法将输入的密码和数据库中的密码进行对比
        else if (validation2(Apassword)) {
            System.out.println("密码输入错误次数过多，账号已被锁定");
        } //调用方法，当返回值为false时，提示登陆成功
        else if (!yzm()){
            System.out.println("登陆成功！");
            a = true;
        }
            return a;
    }
        //登陆验证码
    public static boolean yzm(){
            Scanner sc = new Scanner(System.in);
            while (true) {
                //调用方法获得验证码
                String joint = joint();
                //输出验证码
                System.out.println(joint);
                //键盘录入验证码
                System.out.println("请输入验证码");
                String VerificationCode = sc.next();
                //对比 验证码错误时重新输入，直到输入正确后跳出循环，返回false
                boolean equals = joint.equals(VerificationCode);
                if (!equals){
                   System.out.println("验证码错误，请重新输入");
                }else {
                    break;
                }
            }
        return false;
    }
    //登陆验证码-将数字字母打乱进行拼接
    public static String joint(){
        Random r = new Random();
        //创建StringBuilder变量用来记录
        StringBuilder sb = new StringBuilder();
        //调用方法获得数组与字母的数字并把它们转换成字符串
        String english = new String(english());
        String digital = new String(digital());
        //利用循环获得4个随机字母并添加到StringBuilder里面
        for (int i = 0; i < 4; i++) {
            int n = r.nextInt(english.length());
             char c = english.charAt(n);
             sb.append(c);
        }
        //获得一个随机数字，并添加到StringBuilder里面
        int m = r.nextInt(digital.length());
        char c = digital.charAt(m);
        sb.append(c);
        //定义char变量用来拼接
       char a = ' ';
       //将StringBuilder变量转换为字符串然后转换成char数组
       String szzm = new String(sb);
        char[] chars = szzm.toCharArray();
        //获得随机数
        int i1 = r.nextInt(chars.length);
        //利用循环将数字字母的循序打乱，形成验证码
        for (int i = 0; i < szzm.length(); i++) {
            a = chars[i];
            chars[i] = chars[i1];
            chars[i1] = a;
        }
        //形成字符串返回
        String szzm1 = new String(chars);
        return szzm1;
    }
    //登陆验证码-将字母添加进数组
    public static char[] english() {
        //添加char数组用来添加字母
        char[] english = new char[52];
        //利用循环将字母添加到数组中
        for (int i = 0; i < english.length; i++) {
            if (i > 25) {
                english[i] = (char) (65 + (i - 26));
            } else {
                english[i] = (char) (97 + i);
            }
        }
        return english;
    }
    //登陆验证码-将数字添加进数组-digital-数字
    public static char[] digital(){
        //创建char数组用来添加数字
        char[] digital = new char[10];
        //利用循环将数字添加入数组中
        for (int i = 0; i < digital.length; i++) {
            digital[i] =(char)(48+i);
        }
        return digital;
    }
    //登陆验证密码 验证-validation
    public static boolean validation2(ArrayList<String> Apassword) {
        Scanner sc = new Scanner(System.in);
        //定义变量用来记录密码输入的次数
        int num1 = 0;
        //循环3次，有3次输入密码的机会
        for (int n = 2; n >= 0; n--) {
            System.out.println("请输入密码");
            //键盘录入密码
            String password = sc.next();
            //定义变量记录
            int num = 0;
            //循环遍历出集合中的密码
            for (int i = 0; i < Apassword.size(); i++) {
                String s = Apassword.get(i);
                //进行对比，当对比成功时，num++
                boolean equals = password.equals(s);
                if (equals) {
                    num++;
                }
            }
            //当num==0时，代表密码错误
            if (num == 0) {
                System.out.println("密码错误，你还有" + (n) + "次机会");
                num1++;
                //当num>0时代表密码匹配成功
            } else if (num > 0) {
                break;
            }
        }
        //当num1==3时代表密码次数达到上限，返回true，反之返回false
        if (num1 == 3) {
            return true;
        } else {
            return false;
        }
    }

    //登陆验证用户名 验证-validation
    public static boolean validation1(ArrayList<String> Aname, String name) {
        //定义boolean变量用来记录
        boolean ename;
        //定义变量用来记录true的次数
        int num = 0;
        //遍历用户名集合
        for (int i = 0; i < Aname.size(); i++) {
            //将输入的用户名进行对比，对比上了num++
            ename = name.equals(Aname.get(i));
            if (ename) {
                num++;
            }
        }
        //当num==0时，代表用户名集合里面没有，返回true，提示没有注册
        if (num == 0) {
            return true;
        }
        return false;
    }

    //注册
    public static void Username(ArrayList<String> Aname, ArrayList<String> Apassword, ArrayList<String> Acard, ArrayList<String> Aphone, use use) {
        Scanner sc = new Scanner(System.in);
        //注册用户名
        while (true) {
            //键盘录入用户名
            int a = 0;
            System.out.println("请输入用户名");
            String name = sc.nextLine();
            //调用方法判断长度
            boolean length = length(name);
            //调用方法判断是否重复
            boolean repeat = repeat(Aname, name);
            //调用方法判断是否包含标点符号
            boolean combination1 = combination1(name);
            //
            boolean combination2 = combination2(name);
            //判断长度
            if (length) {
                System.out.println("用户名长度不符合要求,请重新输入");
            } else if (repeat) {
                System.out.println("用户名重复，请重新输入");
            } else if (combination1) {
                System.out.println("用户名不能包含标点符号等，请重新输入");
            } else if (combination2) {
                System.out.println("用户名不能为纯数字，请重新输入");
            } else {
                System.out.println("用户名输入正确");
                Aname.add(name);
                use.setUsername(Aname.toString());
                break;
            }
        }
        //注册密码
        while (true) {
            //键盘录入密码
            System.out.println("请输入密码");
            //输入第一遍密码
            String password1 = sc.next();
            System.out.println("请再次输入密码");
            //输入第二遍密码
            String password2 = sc.next();
            //将两次密码对比，一样的话提示密码注册成功，如果不一样就重新输入
            if (password1.equals(password2)) {
                System.out.println("密码注册成功");
                Apassword.add(password1);
                use.setPassword(Apassword.toString());
                break;
            } else {
                System.out.println("两次输入的密码不同，请重新输入");
            }
        }
        //注册身份证号
        while (true) {
            System.out.println("请输入身份证号码");
            //键盘录入身份证号码
            String card = sc.next();
            //判断身份证的长度的是否为18，不是为true，是为false
            boolean b = card.length() != 18;
            //判断身份证的第一位是否为0，不是为true，是为false
            boolean b1 = card.charAt(0) != '0';
            //调用方法判断前17位是否为纯数字
            boolean num = num(card);
            //判断最后一位是否在0~9，x，X的范围内
            boolean last = last(card);
            if (b) {
                System.out.println("身份证长度错误，请重新输入");
            } else if (!b1) {
                System.out.println("身份证第一位格式错误，请重新输入");
            } else if (num) {
                System.out.println("身份证前17位格式错误，请重新输入");
            } else if (last) {
                System.out.println("身份证最后一位格式错误，请重新输入");
            } else {
                System.out.println("身份证录入成功！");
                Acard.add(card);
                use.setCard(Acard.toString());
                break;
            }

        }
        //注册手机号
        while (true) {
            //键盘录入手机号
            System.out.println("请输入你的手机号码");
            String phone = sc.next();
            boolean b = phone.length() != 11;//相等为false，不相等为true
            boolean b1 = phone.charAt(0) != '0';//相等为false，不相等为true
            boolean digital = digital(phone);
            if (b) {
                System.out.println("手机号长度输入错误，请重新输入");
            } else if (!b1) {
                System.out.println("手机号第一位不能为0，请重新输入");
            } else if (digital) {
                System.out.println("手机号只能为纯数字");
            } else {
                System.out.println("手机号验证成功");
                Aphone.add(phone);
                use.setPhoneNumber(Aphone.toString());
                break;
            }
        }
        System.out.println("账号注册成功！！！");
        System.out.println("请记住您的账户密码！！！");
    }


    //判断用户名的长度是否符合要求
    public static boolean length(String name) {
        if (name.length() > 15 || name.length() < 3) {
            return true;
        }
        return false;
    }

    //判断用户名是否存在  repeat-重复
    public static boolean repeat(ArrayList<String> Aname, String name) {
        //利用循环遍历用户名集合判断用户名是否重复
        for (int i = 0; i < Aname.size(); i++) {
            boolean panduan = Aname.get(i).equals(name);
            if (panduan) {
                System.out.println("用户名重复，请重新输入");
                return true;
            }
        }
        return false;
    }

    //判断用户名的组合是否正确 组合=combination
    public static boolean combination1(String name) {
        //创建一个数组用来记录数字和字母，然后遍历和输入的用户名进行对比
        //如果用户名里有一个在数组中不存在，那么就输入错误,需要重新输入
        char[] zmsz = new char[62];
        char a = 'a' - 1;
        char A = 'A' - 1;
        char num = '0' - 1;
        //将需要的数据添加到数组中
        for (int i = 0; i < zmsz.length; i++) {
            if (i > 51) {
                num++;
                zmsz[i] = num;
            } else if (i > 25) {
                A++;
                zmsz[i] = A;
            } else {
                a++;
                zmsz[i] = a;
            }
        }
        //将数组装换成字符串
        String s = "";
        for (int i = 0; i < zmsz.length; i++) {
            s = s + zmsz[i] + "";
        }
        //利用循环嵌套，将name里的每一个字符进行对比
        int b;
        boolean equals = true;
        for (int i = 0; i < name.length(); i++) {
            b = 0;
            for (int n = 0; n < zmsz.length; n++) {
                //转换成字符串形式
                String c = name.charAt(i) + "";
                String s1 = s.charAt(n) + "";
                equals = c.equals(s1);
                if (!equals) {
                    //将用户名的每一个字符进行对比
                    //当用户名的字符和数组中的字符不同时，输出false，相同时输出true
                    //当输出false时，b++;
                    //如果字符存在'a'~'b',A~B,0~9中 那么就只会有61个false
                    b++;
                }
                //当b==62时，说明用户名中有字符不符合要求
                if (b == 62) {
                    //如果有不同的，就说明不符合要求，返回true
                    return true;
                }
            }
        }
        //符合要求，返回false
        return false;
    }

    //判断用户名的组合是否为纯数字 组合=combination
    public static boolean combination2(String name) {
        char a = 'a' - 1;
        char A = 'A' - 1;
        char[] zm = new char[52];
        //利用循环将字母的大小写添加到数组中
        for (int i = 0; i < zm.length; i++) {
            if (i > 25) {
                a++;
                zm[i] = a;
            } else {
                A++;
                zm[i] = A;
            }
        }
        //定义一个变量用来记录
        int num1 = 0;
        //先利用循环将name遍历出来，在嵌套zm（字母的大小写）.length的循环
        //将name里面的字符和zm（字母的大小写）数组进行对比
        for (int i = 0; i < name.length(); i++) {
            for (int n = 0; n < zm.length; n++) {
                //将char转换为String
                String sz = zm[n] + "";
                String sn = name.charAt(i) + "";
                //对比 当name字符为字母时，输出true
                //当name字符为数字时，输出false
                boolean equals = sn.equals(sz);
                //当对比结果为true时，num1++
                if (equals) {
                    num1++;
                }
            }
        }
        //当num1为0时，代表用户名为纯数字，返回true
        if (num1 == 0) {
            return true;
        }
        return false;
    }

    //判断身份证前17位是否为纯数字
    public static boolean num(String card) {
        //添加数组用来记录0~9的数字
        char[] num = new char[10];
        char num1 = '0' - 1;
        //利用循环将数字添加到数组中
        for (int i = 0; i < num.length; i++) {
            num1++;
            num[i] = num1;
        }
        //利用循环将身份证的字符遍历出来
        //在嵌套循环将身份证的每一个字符和数字数组对比
        //定义变量用来记录
        for (int i = 0; i < card.length() - 1; i++) {
            int numer = 0;
            for (int n = 0; n < num.length; n++) {
                //对比,相同为true，不同为false
                boolean equals = (card.charAt(i) + "").equals(num[n] + "");
                //当输出为false时，numer++
                if (!equals) {
                    numer++;
                }
            }
            //因为身份证前17位只能是数字（0~9），所以正常来说numer只能等于9
            //当numer等于10时，代表前17位有字母，所以返回true
            if (numer == 10) {
                return true;
            }
        }
        return false;
    }

    //判断身份证的最后一位
    public static boolean last(String card) {
        //添加数组用来记录0~9的数字
        char[] num = new char[12];
        char num1 = '0' - 1;
        char x = 'x';
        char X = 'X';
        //定义变量用来记录
        int numer = 0;
        //利用循环将数字添加到数组中
        for (int i = 0; i < num.length; i++) {
            num1++;
            num[i] = num1;
            if (i == 10) {
                num[i] = x;
            } else if (i == 11) {
                num[i] = X;
            }
        }
        //将身份证最后一位转为字符串
        String s = card.charAt(card.length() - 1) + "";
        //利用循环判断
        for (int i = 0; i < num.length; i++) {
            //将身份证的最后一位拿出来和数组中的值对比，相同为true
            boolean equals = s.equals(num[i] + "");
            //当equals==true时，numer++
            if (equals) {
                numer++;
            }
        }
        //因为身份证只能是0~9和x以及X，所以当格式正确的时候
        //numer==1，当numer==0时表示，输入的身份证最后一位不在0~9，x，X的范围中，返回true
        if (numer == 0) {
            return true;
        } else {
            return false;
        }
    }

    //判断手机号是否都为数字 数字-digital
    public static boolean digital(String phone) {
        //添加数组 记录0~9的数字
        char num = '0' - 1;
        char[] num1 = new char[10];
        //利用循环将数字添加到数组中
        for (int i = 0; i < num1.length; i++) {
            num++;
            num1[i] = num;
        }
        //定义变量记录数据
        int num2 = 0;
        //利用循环将手机号码的字符遍历出来
        //在嵌套循环将手机号的每一个字符和数字数组对比
        for (int i = 0; i < phone.length(); i++) {
            for (int n = 0; n < num1.length; n++) {
                //将字符转换为字符串
                String s = phone.charAt(i) + "";
                String s1 = num1[n] + "";
                //对比，数据相同时为true
                boolean equals = s.equals(s1);
                //当equals的值为true时，num2++
                if (equals) {
                    num2++;
                }
            }
        }
        /*
        对比举例：
        5---1 false     当equals的结果为true时
        5---2 false     num2++
        5---3 false     因为如果手机号是纯数字的话，num2必定加一
        5---4 false     又因为手机号一共有11位
        5---5 true      所以，当num2<11时，表示手机号不是纯数字
        5---6 false     所以返回true
        5---7 false
        5---8 false
        5---9 false
        5---0 false
        */
        if (num2 < 11) {
            return true;
        }
        return false;
    }
    //添加学生
    public static void add(ArrayList<Students> as) {
        //键盘录入
        Scanner sc = new Scanner(System.in);
        //创建学生对象
        Students s = new Students();
        String id = null;
        while (true) {
            //键盘录入学生的各项信息
            System.out.println("请输入id");
            id = sc.next();
            //调用方法判断学生id是否重复
            boolean pd = pd(as, id);
            if (pd){
                System.out.println("id重复，请重新输入");
            }else {
                s.setId(id);
                break;
            }
        }
        System.out.println("请输入年龄");
        int age = sc.nextInt();
        s.setAge(age);
        System.out.println("请输入姓名");
        String name = sc.next();
        s.setNeme(name);
        System.out.println("请输入住址");
        String zz = sc.next();
        s.setAddress(zz);
        //将学生对象添加到集合中
        as.add(s);
        System.out.println("录入成功");
    }
    //判断学生id是否重复
    public static boolean pd(ArrayList<Students> as,String id){
        //利用循环将集合中的数据提取出来，再将需要判断的数据进行对比
        for (int i = 0; i < as.size(); i++) {
            Students asget = as.get(i);
            //如果数据存在，返回true
            if (asget.getId().equals(id)){
                return true;
            }
        }
        //如果不存在，返回false
        return false;
    }
    //查找学生id并返回索引
    public static int pd2(ArrayList<Students> as,String id){
        //利用循环将集合中的数据提取出来，再将需要判断的数据进行对比
        for (int i = 0; i < as.size(); i++) {
            Students asget = as.get(i);
            //如果数据存在，返回索引i
            if (asget.getId().equals(id)){
                return i;
            }
        }
        //如果不存在，返回-1
        return -1;
    }
    //删除学生
    public static void delete(ArrayList<Students> as){
        //键盘录入需要删除的学生id
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要删除的学生id");
        String ID = sc.next();
        //调用方法 获得对应id的索引
        int pd = pd2(as, ID);
        //进行判断 如果存在，则删除成功，如果不存在则提示没有id
        if (pd>=0){
            as.remove(pd);
            System.out.println("删除成功");
        }else {
            System.out.println("没有此id");
        }

    }
    //修改学生
    public static void modification(ArrayList<Students> as){
        //键盘录入需要修改的学生的id
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要修改信息的学生的id");
        String id = sc.next();
        //调用方法获得需要修改的信息的索引
        int pd = pd2(as, id);
        //判断（索引不能<0如果<0，代表没有此学生的id）
        if (pd>=0){
            String ID = null;
            //利用循环进行判断，如果修改了的id和已有的id重复，提示修改失败，并重新输入
            while (true) {
                System.out.println("请输入新的学生id");
                ID = sc.next();
                //调用方法判断id是否重复
                boolean PD = pd(as, ID);
                if (PD){
                    System.out.println("修改的id重复，请重新输入id");
                }else {
                    //当修改的id和已有的id没有重复时，跳出循环
                    break;
                }
            }
            System.out.println("请输入新的学生年龄");
            int age = sc.nextInt();
            System.out.println("请输入新的学生姓名");
            String name = sc.next();
            System.out.println("请输入新的学生住址");
            String zz = sc.next();
            //将修改完的数据添加到学生对象，然后添加到集合
            Students stt = new Students(ID,name,age,zz);
            as.set(pd,stt);
        }else {
            System.out.println("没有此id");
        }
    }
    //查询学生
    public static void query(ArrayList<Students> as){
        //判断集合是否为空
        if (as.size()==0){
            System.out.println("当前无学生信息");
            return;
        }//打印目录
        System.out.println("id\t姓名\t年龄\t家庭住址");
        //遍历集合并打印学生信息
        for (int i = 0; i < as.size(); i++) {
            System.out.println(as.get(i).getId()+"\t"+as.get(i).getNeme()+"\t"+as.get(i).getAge()+"\t"+as.get(i).getAddress());
        }
    }
}