javaSE ArrayList&学生管理系统

🕗 发布于 2024-07-03 22:10 java

集合

集合的基本使用

为什么要有集合

集合，在高中数学里面的用处是存放元素。那么推理到Java，集合也是存放元素的。

数组也是存放元素的，因此集合和数组有什么区别

集合的长度可变。

在定义数组的时候我们就要确定数组的大小；在后面就不可以改变了。而集合可以。往集合里面存放元素，那么集合的长度自动加1.
存储类型

数组可以存放基本数据类型和引用数据类型，而集合可以直接存放引用集合类型，在存放基本数据类型的时候需要转换成包装类。

ArrayList

在学习新的类的时候，都可以使用jdk提供的api帮助文档。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

首先，学习一下如何定义ArrayList。

先回顾一下数组是怎么定义的

String[] arr = new String[10];

接下来我们学习集合是怎么定义的

ArrayList <String> list = new ArrayList<>();

在集合定义的时候有一个<>泛型、这里的泛型用来限定集合中的元素类型。因此在帮助文档上 类 ArrayList<E>中的<E>是泛型的意思。

如果是ArrayList <int> list = new ArrayList<>();那么就会出问题，因为int属于基本数据类型。而集合默认存放引用数据类型。

在JDK7以前定义方式如下

ArrayList <String> list = new ArrayList<String>();

现在用的都高于7，因此可以直接ArrayList <String> list = new ArrayList<>();但是要注意<>还要跟上。

import java.util.ArrayList;

public class ArrayListDemo01 {
    public static void main(String[] args) {
        ArrayList <String> list = new ArrayList<>();
        System.out.println(list);  // []
    }
}

对于这段代码的输出并不是内存地址，而是[]这是因为ArrayList类在在底层做了一些处理。

比如打印对象名输出的是数据内容而不是地址，内容用[]包裹。对象sb也在在底层做了处理。

构造方法

方法名	说明
public ArrayList()	创建一个空的集合对象

成员方法

方法名	说明
public boolean add(要添加的元素)	将指定的元素追加到此集合的末尾
public boolean remove(要删除的元素)	删除指定元素,返回值表示是否删除成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size()	返回集合中的元素的个数

示例代码

import java.util.ArrayList;

public class ArrayListDemo02 {
    public static void main(String[] args) {
        //创建集合
        ArrayList <String> list = new ArrayList<>();

        // 添加
        boolean addResult = list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        System.out.println(addResult);  // true
        System.out.println(list);  // [aaa, bbb, ccc, ddd, eee]

        // 删除
        list.remove("bbb");
        System.out.println(list);  // [aaa, ccc, ddd, eee]
        String removeResult = list.remove(2);
        System.out.println(removeResult);  // ddd

        // 修改
        String setResult = list.set(0, "zzz");
        System.out.println(setResult);  // aaa
        System.out.println(list);  // [zzz, ccc, eee]

        // 查找
        String getResult = list.get(2);
        System.out.println(getResult);  // eee

        // 遍历
        for (int i=0; i<list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

以上是常见集合的操作。

在这里我补充一点，集合还有好多，

ArrayList：ArrayList是基于动态数组实现的随机访问列表，它的元素可以重复，且保持了插入顺序。其特点是访问速度快，但增删操作比较慢，因为它需要在数组中移动元素来填补或腾出空间。
LinkedList：LinkedList是一个双向链表，它除了实现List接口，还实现了Deque接口，因此可以作为队列使用。与ArrayList相比，LinkedList在插入和删除方面具有更好的性能，尤其是在列表的中间或开始处插入或删除元素时。
HashSet：HashSet是基于哈希表实现的无序集合，它不允许有重复元素。其通过哈希值来快速查找和存储元素，适合用于判断某个元素是否存在于集合中。HashSet的一个重要用途是去除重复元素，例如在数据库中筛选唯一记录。
TreeSet：TreeSet是一个有序的集合，它实现了SortedSet接口。元素在TreeSet中按照自然排序（或者由Comparator确定的排序）进行排列。TreeSet内部使用红黑树数据结构，特别适合于需要有序集合的场景，如范围查询和排序操作。
HashMap：HashMap可能是Java中使用最频繁的集合类之一。它实现了Map接口，存储键值对映射关系。HashMap通过哈希表实现，具有很高的查找速度和存储效率。在HashMap中，允许使用一个null键和多个null值，这使得它的应用场景非常广泛。

以上来源人工智能。

案例

ArrayList存储字符串并遍历

创建一个存储字符串的集合，存储3个字符串元素，使用程序实现在控制台遍历该集合

遍历格式参照：[元素1，元素2，元素3]。

import java.util.ArrayList;

public class ArrayListTest01 {
    public static void main(String[] args) {
        ArrayList <String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        System.out.print('[');
        for (int i = 0; i < list.size(); i++) {
            if (i == list.size()-1) System.out.print(list.get(i) + "]");
            else System.out.print(list.get(i) + ", ");
        }
    }
}

这种类似的题目已经做过了。

只不过集合的循环方式不再是[i]而是.get(i)

这里集合的数据都是String，引用数据类型。那么换成基本数据类型呢，需要使用包装类。

对于基本类型的包装类

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

import java.util.ArrayList;

public class ArrayListTest03 {
    public static void main(String[] args) {
        ArrayList <Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        System.out.print('[');
        for (int i = 0; i < list.size(); i++) {
            if (i == list.size()-1) System.out.print(list.get(i) + "]");
            else System.out.print(list.get(i) + ", ");
        }
    }
}

import java.util.ArrayList;

public class ArrayListTest04 {
    public static void main(String[] args) {
        ArrayList <Character> list = new ArrayList<>();
        list.add('a');
        list.add('b');
        list.add('c');

        System.out.print('[');
        for (int i = 0; i < list.size(); i++) {
            if (i == list.size()-1) System.out.print(list.get(i) + "]");
            else System.out.print(list.get(i) + ", ");
        }
    }
}

以上是包装类的使用

ArrayList存储学生对象并遍历

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

import java.util.ArrayList;

class Student{
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName(){
        return this.name;
    }

    public int getAge(){
        return this.age;
    }
}

public class ArrayListTest02 {
    public static void main(String[] args) {
        ArrayList <Student> list = new ArrayList<>();
        Student stu1 = new Student("张三", 18);
        Student stu2 = new Student("李四", 18);
        Student stu3 = new Student("王五", 18);

        list.add(stu1);
        list.add(stu2);
        list.add(stu3);

        for (int i=0; i<list.size(); i++) {
            Student stu = list.get(i);
           System.out.println(stu.getName() + " " + stu.getAge());
        }

    }
}

以上是吧学生信息直接写死了，现在需要改成可以输入的。

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

class StudentTest05{
    private String name;
    private int age;

    public StudentTest05() {
    }

    public StudentTest05(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class ArrayListTest05 {


    public static void main(String[] args) {
        ArrayList <StudentTest05> list = new ArrayList<>();
        Scanner sc = new Scanner(System.in);

        // 存放三个学生
        for (int i = 0; i <3 ; i++) {
            StudentTest05 stu05 = new StudentTest05();

            System.out.println("请输入学生姓名");
            String name = sc.next();
            System.out.println("请输入学生年龄");
            int age = sc.nextInt();

            stu05.setName(name);
            stu05.setAge(age);

            list.add(stu05);
        }

        for (int i=0; i<list.size(); i++) {
            StudentTest05 stu05 = list.get(i);
            System.out.println(stu05.getName() + " " + stu05.getAge());
        }

    }
}

一个完整的Java Bean类应该包括空参构造、全参构造。还有.get()和.set()方法

生成构造方法是有快捷键的alt+insert打开Generate，选择Constructor；Choose Fields to Initialize by Constructor选择要由构造函数初始化的字段。全不选就是空参构造，选了就是含参构造。

同样alt+insert打开Generate选择Getter and Setter生成.get()和.set()方法

查找用户的索引

main方法中定义一个集合，存入三个用户对象。

用户属性为：id，username，password

要求：定义一个方法，根据id查找对应的用户信息。

如果存在，返回索引；如果不存在，返回-1

import java.util.ArrayList;
import java.util.GregorianCalendar;

class User{
    private String id;
    private String username;
    private String password;

    public User() {
    }

    public User(String id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}
public class ArrayListTest06 {
    public static void main(String[] args) {
        ArrayList<User> list= new ArrayList<>();

        User u1 = new User("001", "zhangsan", "zhangsan123");
        User u2 = new User("002", "lisi", "lisi456");
        User u3 = new User("003", "wangwu", "wangwu789");

        list.add(u1);
        list.add(u2);
        list.add(u3);

        boolean result = contains(list, "002");
        System.out.println(result);
        int resultId = getIndex(list, "002");
        System.out.println(resultId);
    }

    public static boolean contains(ArrayList<User> list, String id){
        for (int i = 0; i < list.size(); i++) {
            User u = list.get(i);
            String uId = u.getId();
            if (uId.equals(id)) return true;
        }
        return false;
    }

    public static int getIndex(ArrayList<User> list, String id){
        for (int i = 0; i < list.size(); i++) {
            User u = list.get(i);
            String uId = u.getId();
            if (uId.equals(id)) return i;
        }
        return -1;
    }


}

写了两种方法、信息存在返回true，不存在返回false。也可以是存在返回索引，不存在返回-1；索引没有-1

添加手机对象并返回要求的数据

定义lavabean类：Phone，Phone/属性：品牌，价格。

main方法中定义一个集合，存入三个手机对象。分别为：小米，1000。苹果，8000。锤子2999。

定义一个方法，将价格低于3000的手机信息返回

import java.util.ArrayList;
import java.util.List;

class Phone{
    private String brand;
    private float price;

    public Phone() {
    }

    public Phone(String brand, float price) {
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }
}
public class ArrayListTest07 {
    public static void main(String[] args) {
        ArrayList<Phone> list = new ArrayList<>();

        Phone p1 = new Phone("小米",1000);
        Phone p2 = new Phone("苹果", 8000);
        Phone p3 = new Phone("锤子",2999);

        list.add(p1);
        list.add(p2);
        list.add(p3);

        ArrayList<Phone> showList = show(list);
        for (int i = 0; i < showList.size(); i++) {
            Phone p = showList.get(i);
            System.out.println(p.getBrand() + "," + p.getPrice());
        }

    }

    public static ArrayList<Phone> show(ArrayList<Phone> list){
        ArrayList<Phone> showList = new ArrayList<>();

        for (int i = 0; i < list.size(); i++) {
            Phone p = list.get(i);
            if (p.getPrice()<3000){
                showList.add(p);  // 符合条件，添加到集合
            }
        }

        return showList;
    }

}

我犹豫了一下，这对信息怎么返回。返回一堆信息可以用数组和集合、我选择了集合。

学生管理系统

标准版

需求：

采取控制台的方式去书写学生管理系统。

分析：

初始菜单：
"-------------欢迎来到黑马学生管理系统----------------"
"1：添加学生"
"2：删除学生"
"3：修改学生"
"4：查询学生"
"5：退出"
"请输入您的选择:"
学生类：

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

添加功能：

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

id唯一

删除功能：

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

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

修改功能：

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

id存在，继续录入其他信息
id不存在，需要提示不存在，并回到初始菜单

查询功能：

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

如果没有学生信息，提示：当前无学生信息，请添加后再查询
如果有学生信息，需要按照以下格式输出。（不用过于纠结对齐的问题）
id姓名年龄家庭住址
heima001张三23 南京
heima002李四24 北京
heima003王五25 广州
heima004赵六 26 深圳

Java Bean类

package Standard;

public class Student {
    private String id;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String id, String name, int age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

测试类

package Standard;

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

public class StudentSystem {
    public static void main(String[] args) {

        ArrayList<Student> studentsList = new ArrayList<>();
        // 测试数据
        Student stu1 = new Student("heima001", "张三", 23, "南京");
        Student stu2 = new Student("heima002", "李四", 24, "北京");
        Student stu3 = new Student("heima003", "王五", 25, "广州");
        Student stu4 = new Student("heima004", "张三", 25, "北京");
        Student stu5 = new Student("heima005", "李勇", 24, "广州");

        studentsList.add(stu1);
        studentsList.add(stu2);
        studentsList.add(stu3);
        studentsList.add(stu4);
        studentsList.add(stu5);
        // 显示菜单

        while (true){
            int num = menu();
            switch(num){
                case 1 -> addStudent(studentsList);
                case 2 -> deleteStudent(studentsList);
                case 3 -> updateStudent(studentsList);
                case 4 -> queryStudent(studentsList);
                case 5 -> printStudents(studentsList);
                case 0 -> {
                    System.out.println("退出程序");
                    System.exit(0);  // 停止虚拟机运行
                }
                default -> System.out.println("没有这个选项");
            }
        }

    }

    public static int menu(){
        Scanner sc = new Scanner(System.in);
        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("0：退出");
        System.out.println("请输入您的选择:");
        return sc.nextInt();
    }

    // 添加学生
    public static void addStudent(ArrayList<Student> studentsList){
        Scanner sc = new Scanner(System.in);
        Student stu = new Student();

        System.out.println("添加学生");

        System.out.print("请输入学生id: ");
        String id = sc.next();

        stu.setId(id);

        System.out.print("请输入学生姓名: ");
        String name = sc.next();
        stu.setName(name);

        System.out.print("请输入学生年龄: ");
        int age = sc.nextInt();
        stu.setAge(age);

        System.out.print("请输入学生地址: ");
        String address = sc.next();
        stu.setAddress(address);

        // 添加学生业务逻辑
        boolean result = checkId(studentsList, id);
        if (!result) {
            studentsList.add(stu);
            System.out.println("[info: Success ] 学生添加成功！");
        }else {
            System.out.println("[info: failure ] 学生添加失败！学生存在");   // id唯一
        }
    }

    // 删除学生
    public static void deleteStudent(ArrayList<Student> studentsList){
        Scanner sc = new Scanner(System.in);
        System.out.println("删除学生");
        System.out.print("请输入学生id: ");
        String id = sc.next();

        boolean result = checkId(studentsList, id);  // 判断学生是否存在
        if (result) {
            // 根据id找到对应的学生
            for (int i = 0; i < studentsList.size(); i++) {
                Student stu = studentsList.get(i);
                String stuId = stu.getId();
                if (stuId.equals(id)) studentsList.remove(i);
            }
            System.out.println("[info: Success ] 学生删除成功！");
        }else {
            System.out.println("[info: failure ] 学生删除失败！学生不存在");   // id唯一
        }
    }

    // 修改学生
    public static void updateStudent(ArrayList<Student> studentsList){
        Scanner sc = new Scanner(System.in);
        System.out.println("修改学生");
        System.out.print("请输入学生id: ");
        String id = sc.next();

        boolean result = checkId(studentsList, id);  // 判断学生是否存在

        // 学生存在，进行修改
        if (result) {
            int num = updateStudentMenu();
            for (int i = 0; i < studentsList.size(); i++) {
                Student stu = studentsList.get(i);  // 找到需要修改的学生
                switch (num){
                    // 修改学生姓名
                    case 1 ->{
                        System.out.print("请输入学生新的姓名: ");
                        String name = sc.next();
                        stu.setName(name);
                        System.out.println("[info: Success ] 学生家庭姓名信息成功！");
                    }

                    // 修改学生年龄
                    case 2 -> {
                        System.out.print("请输入学生新的年龄: ");
                        int age = sc.nextInt();
                        stu.setAge(age);
                        System.out.println("[info: Success ] 学生年龄信息成功！");
                    }

                    // 修改学生家庭住址
                    case 3 -> {
                        System.out.print("请输入学生新的家庭地址: ");
                        String address = sc.next();
                        stu.setAddress(address);
                        System.out.println("[info: Success ] 学生家庭住址信息成功！");
                    }
                    default -> System.out.println("没有这个选项");
                }
                break;
            }
        }else {
            System.out.println("[info: failure ] 学生不存在");   // id唯一
        }
    }

    // 查询学生
    public static void queryStudent(ArrayList<Student> studentsList){
        Scanner sc = new Scanner(System.in);
        System.out.println("查询学生");
        int num = queryStudentMenu(); // 显示查找规则
        switch (num){
            // 修改学生姓名
            case 1 ->{
                System.out.println("请输入需要查找的学生姓名: ");
                String name = sc.next();
                // 找相同name的学生
                System.out.println("已找到姓名是" + name + "的学生");
                System.out.println("id" + "\t\t\t" + "姓名" + '\t' + "年龄" + '\t' + "家庭住址" );
                for (int i = 0; i <studentsList.size() ; i++) {
                    Student stu = studentsList.get(i);  // 遍历学生集合
                    String stuName = stu.getName();  // 得到学生姓名
                    if (stuName.equals(name)) {
                        String stuId = stu.getId();
                        int stuAge = stu.getAge();
                        String stuAddress = stu.getAddress();
                        System.out.println(stuId + '\t' + stuName + '\t' + stuAge + '\t' + stuAddress);
                    }
                }
            }

            // 修改学生年龄
            case 2 -> {
                System.out.print("请输入需要查找的学生年龄: ");
                int age = sc.nextInt();
                // 找相同name的学生
                System.out.println("已找到年龄是" + age + "的学生");
                System.out.println("id" + "\t\t\t" + "姓名" + '\t' + "年龄" + '\t' + "家庭住址" );
                for (int i = 0; i <studentsList.size() ; i++) {
                    Student stu = studentsList.get(i);  // 遍历学生集合
                    int stuAge = stu.getAge();
//                    System.out.println(stu.getName());
                    if (stuAge == age ) {
                        String stuName = stu.getName();
                        String stuId = stu.getId();
                        String stuAddress = stu.getAddress();
                        System.out.println(stuId + '\t' + stuName + '\t' + stuAge + '\t' + stuAddress);

                    }
                }
            }

            case 3 -> {
                System.out.print("请输入需要查找的学生家庭地址: ");
                String address = sc.next();
                System.out.println("已找到家庭地址是" + address + "的学生");
                System.out.println("id" + "\t\t\t" + "姓名" + '\t' + "年龄" + '\t' + "家庭住址" );
                for (int i = 0; i <studentsList.size() ; i++) {
                    Student stu = studentsList.get(i);  // 遍历学生集合
                    String stuAddress = stu.getAddress();
                    if (stuAddress.equals(address)) {
                        String stuId = stu.getId();
                        String stuName = stu.getName();
                        int stuAge = stu.getAge();
                        System.out.println(stuId + '\t' + stuName + '\t' + stuAge + '\t' + stuAddress);
                    }
                }
            }
            default -> System.out.println("没有这个选项");
        }


    }

    // 检查id
    public static boolean checkId(ArrayList<Student> studentsList, String id) {
        for (int i = 0; i < studentsList.size(); i++) {
            String stuId = studentsList.get(i).getId();  // 获取集合中学生id
            if (id.equals(stuId)) return true;
        }
        return false;
        }

    // 按字段修改数据
    public static int updateStudentMenu(){
        Scanner sc = new Scanner(System.in);
        System.out.println("1：修改学生姓名");
        System.out.println("2：修改学生年龄");
        System.out.println("3：修改学生家庭地址");
        System.out.println("请选择!");
        return sc.nextInt();
    }

    // 按字段查找数据
    public static int queryStudentMenu(){
        Scanner sc = new Scanner(System.in);
        System.out.println("1：按学生姓名查找");
        System.out.println("2：按学生年龄查找");
        System.out.println("3：按学生家庭地址查找");
        System.out.println("请选择!");
        return sc.nextInt();
    }


    // 打印全部学生
    public static void printStudents(ArrayList<Student> studentsList) {
        System.out.println("id" + "\t\t\t" + "姓名" + '\t' + "年龄" + '\t' + "家庭住址" );
        for (Student stu : studentsList) {
            String id = stu.getId();
            String name = stu.getName();
            int age = stu.getAge();
            String address = stu.getAddress();
            System.out.println(id + '\t' + name + '\t' + age + '\t' + address);
        }
    }
}

运行结果

-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
5
id姓名年龄家庭住址
heima001张三23南京
heima002李四24北京
heima003王五25广州
heima004张三25北京
heima005李勇24广州
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
1
添加学生
请输入学生id: heima0001
请输入学生姓名: aa
请输入学生年龄: 22
请输入学生地址: 天津
[info: Success ] 学生添加成功！
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
5
id姓名年龄家庭住址
heima001张三23南京
heima002李四24北京
heima003王五25广州
heima004张三25北京
heima005李勇24广州
heima0001aa22天津
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
2
删除学生
请输入学生id: hh
[info: failure ] 学生删除失败！学生不存在
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
2
删除学生
请输入学生id: heima0001
[info: Success ] 学生删除成功！
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
5
id姓名年龄家庭住址
heima001张三23南京
heima002李四24北京
heima003王五25广州
heima004张三25北京
heima005李勇24广州
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
1
添加学生
请输入学生id: heima001
请输入学生姓名: ss
请输入学生年龄: 11
请输入学生地址: rib
[info: failure ] 学生添加失败！学生存在
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
3
修改学生
请输入学生id: heima001
1：修改学生姓名
2：修改学生年龄
3：修改学生家庭地址
请选择!
3
请输入学生新的家庭地址: 广州
[info: Success ] 学生家庭住址信息成功！
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
4
查询学生
1：按学生姓名查找
2：按学生年龄查找
3：按学生家庭地址查找
请选择!
3
请输入需要查找的学生家庭地址: 广州
已找到家庭地址是广州的学生
id姓名年龄家庭住址
heima001张三23广州
heima003王五25广州
heima005李勇24广州
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
0
退出程序

Process finished with exit code 0

代码写了大约260多行，这是我学Java以来写过最多的一次。但是归根结底是对集合的考察、增删改查的操作；

在编写过程中还是要多写注释，for循环、if判断有时候真的很容易搞混。

升级版

需求：

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

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

分析：

登录界面：
System.out.println("欢迎来到学生管理系统");
System.out.println("请选择操作1登录 2注册 3忘记密码");
用户类：

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

注册功能：

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

验证要求：

用户名唯一

用户名长度必须在3~15位之间

只能是字母加数字的组合，但是不能是纯数字

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

3，身份证号码需要验证。

验证要求：

长度为18位

不能以0为开头

前17位，必须都是数字

最为一位可以是数字，也可以是大写X或小写x

4，手机号验证。

验证要求：

长度为11位

不能以0为开头

必须都是数字

登录功能：

1，键盘录入用户名

2，键盘录入密码

3，键盘录入验证码

验证要求：

用户名如果未注册，直接结束方法，并提示：用户名未注册，请先注册

判断验证码是否正确，如不正确，重新输入

再判断用户名和密码是否正确，有3次机会

忘记密码：

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

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

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

如果一致，则提示输入密码，进行修改。

如果不一致，则提示：账号信息不匹配，修改失败。

验证码规则：

长度为5

由4位大写或者小写字母和1位数字组成，同一个字母可重复

数字可以出现在任意位置

比如：

aQa1K

user类

package Upgrade;

public class User {
    private String username;
    private String password;
    private String phone;
    private String identityCard;

    public User() {

    }

    public User(String username, String password, String phone, String identityCard) {
        this.username = username;
        this.password = password;
        this.phone = phone;
        this.identityCard = identityCard;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        // 手机号必须11位且不能是0开头
        if (phone.length() == 11 && phone.charAt(0) != '0') {
            this.phone = phone;
        }else {
            System.out.println("[info: failure] 手机号不合法");
        }
    }

    public String getIdentityCard() {
        return identityCard;
    }

    public void setIdentityCard(String identityCard) {
        this.identityCard = identityCard;
    }

    // 密码检查
    public boolean checkPassword(String password){
        if (this.password.equals(password)) return true;
        else return false;
    }
}

test类

package Upgrade;

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

public class app {
    public static void main(String[] args) {
//        int welcomeNum = welcomeMenu();  // 接收欢迎菜单返回来的选择
        ArrayList<User> userList = new ArrayList<>();  // 用户集合
        User u = new User("admin", "admin00000", "000", "000");
        userList.add(u);

        while (true){
            int num = welcomeMenu();
            switch (num){
                case 1 -> login(userList);
                case 2 -> register(userList);
                case 3 -> forget(userList);
                case 0 -> {
                    System.out.println("退出程序");
                    System.exit(0);  // 停止虚拟机运行
                }
                default -> System.out.println("没有这个选项");
            }
        }
    }


    // 欢迎菜单
    public static int welcomeMenu(){
        Scanner sc = new Scanner(System.in);
        System.out.println("欢迎来到学生管理系统");
        System.out.println("1: 登录");
        System.out.println("2: 注册");
        System.out.println("3: 忘记密码");
        System.out.println("0: 退出");
        System.out.print("请输入您的选择:");
        return sc.nextInt();
    }


    // 登录
    public static void login(ArrayList<User> userList){
        Scanner sc = new Scanner(System.in);
        String verCode =  VerificationCode.VerificationCodeMain();

        System.out.print("请输入用户名:");
        String usernameInput = sc.next();
        System.out.print("请输入密码:");
        String passwordInput = sc.next();
        System.out.print("请输入验证码 (" + verCode + "): ");
        String verificationCodeInput = sc.next();
        int flag = 3-1;  // 三次机会，已经用过一次了。

        // 验证码验证
        if (verCode.equals(verificationCodeInput)){
            // 判断用户是否 存在
            int res = userExists(userList, usernameInput);
            if (res >= 0) {
                while (true){
                    User u = userList.get(res);
                    if (u.checkPassword(passwordInput)){
                        System.out.println("[info : success ] 登录成功");
                        StudentSystem.startStudentSystem();  // 启动
                        break;
                    } else{
                        if (flag != 0){
                            System.out.print("请重新输入密码（还有" + flag + "次机会）: ");
                            passwordInput = sc.next();
                        }else{
                            System.out.print("[info: ] " + usernameInput + "已锁");
                            break;
                        }
                        flag--;
                    }
                }
                // 判断密码
            }else System.out.println(usernameInput + "不存在");
        }else System.out.println("验证码错误");

    }

    // 注册
    public static void register(ArrayList<User> userList){
        System.out.println("欢迎注册学生管理系统");
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入用户名：");
        String usernameInput = sc.next();
        // 用户名唯一，判断用户是否唯一
        int usernameLen = usernameInput.length();  // 用户名长度必须在3~15位之间
        int res = userExists(userList, usernameInput);
        // 当res返回-1时，用户不存在。
        if (usernameLen>3 && usernameLen <15){
            if (res < 0){
                System.out.print("请输入密码");
                String passwordInput = sc.next();
                // 密码合法
                if (checkInputPassword(passwordInput)){
                    // 验证密码，符合进入二次输入
                    System.out.print("请再次输入密码进行确认：");
                    String passwordInputTwo = sc.next();
                    // 两次密码一致
                    if (passwordInputTwo.equals(passwordInput)) {
                        System.out.println("请输入身份证：");
                        String identityCardInput = sc.next();
                        // 判断身份证是否符合输入
                        if (checkIdentityCard(identityCardInput)){
                            System.out.println("请输入手机号码：");
                            String phoneInput = sc.next();
                            // 验证手机号码
                            if (checkPhone(phoneInput)) {
                                // 用户注册
                                User u = new User(usernameInput, passwordInputTwo, phoneInput, identityCardInput);
                                userList.add(u);
                                System.out.println("[info : success ] 完成注册");
                            }
                            else {
                                System.out.println("[info : failure ] 手机号有误");
                                System.out.println("[info :] 程序结束，请重新运行");
                            }
                        }else {
                            System.out.println("[info : failure ] 身份证号码有误");
                            System.out.println("[info :] 程序结束，请重新运行");
                        }
                    }else {
                        System.out.println("[info : failure ] 两次密码不一致");
                        System.out.println("[info :] 程序结束，请重新运行");
                    }
                }else {
                    System.out.println("[info : failure ] 密码不符合规定");
                    System.out.println("[info :] 程序结束，请重新运行");
                }
            }else {
                System.out.println("[info : failure ] 当前" + usernameInput + "用户已存在，请返回登录！");
                System.out.println("[info :] 程序结束，请重新运行");
            }
        }else{
            System.out.println("[info : failure ] 用户名过短或过长");
            System.out.println("[info :] 程序结束，请重新运行");
        }
    }

    // 忘记密码
    public static void forget(ArrayList<User> userList) {
        Scanner sc = new Scanner(System.in);
        System.out.println("修改密码");
        System.out.print("请输入用户名：");
        String usernameInput = sc.next();
        int userIndex = userExists(userList, usernameInput);
        // 用户要存在，才可以改密码
        if (userIndex >= 0) {
            System.out.println("请输入修改后的密码");
            String passwordInput = sc.next();
            // 密码合法
            if (checkInputPassword(passwordInput)) {
                // 验证密码，符合进入二次输入
                System.out.print("请再次输入密码进行确认：");
                String passwordInputTwo = sc.next();
                if (passwordInputTwo.equals(passwordInput)) {
                    User u = userList.get(userIndex);
                    u.setPassword(passwordInput);  // 设置密码
                    System.out.println("[info : success ] 密码修改完成");
                } else {
                    System.out.println("[info : failure ] 两次密码不一致");
                    System.out.println("[info :] 程序结束，请重新运行");
                }
            }else {
                System.out.println("[info : failure ] 密码不合法");
                System.out.println("[info :] 程序结束，请重新运行");
            }
        }else {
            System.out.println("[info : failure ] 用户不存在");
            System.out.println("[info :] 程序结束，请重新运行");
        }
    }

    // 检查用户
    public static int userExists(ArrayList<User> userList, String username){
        for (int i = 0; i < userList.size(); i++) {
            User u = userList.get(i);
            String uName = u.getUsername();
            // 找到这个用户
            if (uName.equals(username)) return i;
        }
        return -1;
    }

    // 验证输入的密码是否符合
    public static boolean checkInputPassword(String password){
        int strLen = password.length();
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        // 遍历字符串进行统计
        for (int i = 0; i < password.length(); i++) {
            char ch = password.charAt(i);
            // 统计
            if (ch >= 'a' && ch <= 'z') smallCount++;
            else if (ch >= 'A' && ch <= 'Z') bigCount++;
            else if (ch >= '0' && ch <= '9') numberCount++;
        }

        // 长度大于6、包含大小写字母和数字
        if (strLen>6 && bigCount !=0 && smallCount !=0 && numberCount !=0) return true;
        else return false;
    }


    // 检查身份证号码.
    /*
    * 验证规则：长度为18位；不能以0为开头；前17位，必须都是数字；最为一位可以是数字，也可以是大写X或小写x*/
    public static boolean checkIdentityCard(String str){

        // 长度为18位
        if(str.length() != 18) return false;

        // 不能以0为开头
        if (str.charAt(0) == '0') return false;

        // 前17位，必须都是数字
        for (int i = 0; i < str.length()-1; i++) {
            char c = str.charAt(i);
            if (!(c >= '0' && c <= '9')) return false;
        }

        // 最为一位可以是数字，也可以是大写X或小写x
        char endChar= str.charAt(str.length()-1);
        if (!((endChar >= '0' && endChar <= '9') || (endChar == 'x') || endChar == 'X')) return false;
        System.out.println(endChar);
        return true;
    }

    // 验证手机号
    /* 验证要求：长度为11位；不能以0为开头；必须都是数字 */
    public static boolean checkPhone(String str) {

        // 长度为11位
        if (str.length() != 11) return false;

        // 不能以0为开头
        if (str.charAt(0) == '0') return false;

        // 前17位，必须都是数字
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (!(c >= '0' && c <= '9')) return false;
        }

        return true;
    }

    }

运行结果

欢迎来到学生管理系统
1: 登录
2: 注册
3: 忘记密码
0: 退出
请输入您的选择:2
欢迎注册学生管理系统
请输入用户名：zhangsan
请输入密码
Zs111
[info : failure ] 密码不符合规定
[info :] 程序结束，请重新运行
欢迎来到学生管理系统
1: 登录
2: 注册
3: 忘记密码
0: 退出
请输入您的选择:2
欢迎注册学生管理系统
请输入用户名：zhangsan
请输入密码
Zhan111
请再次输入密码进行确认：Zhan111
请输入身份证：
11122233334455667X
X
请输入手机号码：
11122233312
[info : success ] 完成注册
欢迎来到学生管理系统
1: 登录
2: 注册
3: 忘记密码
0: 退出
请输入您的选择:3
修改密码
请输入用户名：zhangsan
请输入修改后的密码
ZZZ1111
[info : failure ] 密码不合法
[info :] 程序结束，请重新运行
欢迎来到学生管理系统
1: 登录
2: 注册
3: 忘记密码
0: 退出
请输入您的选择:3
修改密码
请输入用户名：Zhangsan111
[info : failure ] 用户不存在
[info :] 程序结束，请重新运行
欢迎来到学生管理系统
1: 登录
2: 注册
3: 忘记密码
0: 退出
请输入您的选择:3
修改密码
请输入用户名：zhangsan
请输入修改后的密码
Zhangsan111
请再次输入密码进行确认：Zhangsan111
[info : success ] 密码修改完成
欢迎来到学生管理系统
1: 登录
2: 注册
3: 忘记密码
0: 退出
请输入您的选择:1
请输入用户名:zhangsan
请输入密码:Zhangsan111
请输入验证码 (ZRZ6t): ZRZ6t
[info : success ] 登录成功
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
5
id姓名年龄家庭住址
heima001张三23南京
heima002李四24北京
heima003王五25广州
heima004张三25北京
heima005李勇24广州
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
1
添加学生
请输入学生id: aaaaa
请输入学生姓名: aa
请输入学生年龄: 24
请输入学生地址: aaaa
[info: Success ] 学生添加成功！
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:
5
id姓名年龄家庭住址
heima001张三23南京
heima002李四24北京
heima003王五25广州
heima004张三25北京
heima005李勇24广州
aaaaaaa24aaaa
-------------欢迎来到黑马学生管理系统----------------
1：添加学生
2：删除学生
3：修改学生
4：查询学生
5：打印学生
0：退出
请输入您的选择:

XXX管理系统就是增删改查的操作，总体不难，主要是我写了好多条件语句，很容易搞混。

以上代码都是我自己写的，有一部分看着老师写的。

我认为我写这种管理系统已经是如喝水，但是出现了好多问题。然后我也会把老师的代码敲一遍，

我是模仿其他代码，写了一些提示[info : ]，这样的话我以为更方便使用。

package Upgrade;

import javax.sound.midi.MidiFileFormat;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class AppItheima {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<User> userList = new ArrayList<>();
        User u = new User("admin", "Admin00000", "11122223333", "11122233334455667x");
        userList.add(u);
//        System.out.println(u.getPhone());
//        System.out.println(u.getIdentityCard());
        while (true){
            System.out.println("欢迎来到学生管理系统");
            System.out.println("请选择操作1登录 2注册 3忘记密码");
            String choose = sc.next();
            switch (choose) {
                case "1" -> login(userList);
                case "2" -> register(userList);
                case "3" -> forgetPassword(userList);
                case "0" -> {
                    System.out.println("谢谢使用，再见");
                    System.exit(0);
                }
                default -> System.out.println("没有这个选项");
            }
        }
    }

    public static void login(ArrayList<User> userList){
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入用户名");
            String username = sc.next();

            // 判断用户是否存在
            boolean flag = contain(userList, 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 (code.equalsIgnoreCase(rightCode)){
                    System.out.println("当前验证码正确" );
                    break;
                }else {
                    System.out.println("当前验证确有误，请重新输入！" );
                    continue;
                }
            }

            // 验证用户名和密码是否正确
            // 集合中是否包含用户名和密码
            // 定义一个方法验证用户名和密码是否正确

            // 封装思想的应用
            // 我们可以一些零散的数据封装成一个对象
            // 以后传递参数的时候，只需要传递一个整体就可以了。不需要传递零散的数据
            User userInfo = new User(username, password, null, null);
            boolean res = checkUserInfo(userList, userInfo);
            if (res){
                System.out.println("登陆成功");
                StudentSystem.startStudentSystem();  // 启动
                break;
            }else {
                System.out.println("密码错误，请重新输入");
                if (i == 2) {
                    System.out.println("当前账号"+ username + "已锁定");
                    // 账号锁定之后，直接结束方法
                    return;
                }else {
                    System.out.println("用户名或密码错误，还剩下" + (2-i) + "次机会");
                }
            }
        }

    }

    public static boolean checkUserInfo(ArrayList<User> userList, User userInfo) {
        for (int i = 0; i < userList.size(); i++) {
            User u = userList.get(i);
            if (u.getUsername().equals(userInfo.getUsername()) && u.getPassword().equals(userInfo.getPassword())){
                return true;
            }
        }
        return false;
    }

    public static void register(ArrayList<User> userList){
        Scanner sc = new Scanner(System.in);
        String username, password, identityCard, phone;
        // 用户名、密码，身份证号码、手机号码放到用户对象中；
        // 把用户对象添加到集合中；
        // 1.键盘录入用户名
        while (true) {
            System.out.println("请输入用户名");
            username = sc.next();
            /*
            * 开发细节：
            * 先验证格式正确；再验证是否唯一
            * 因为数据都存放在数据库中，如果需要校验，需要使用网络资源
            */

            boolean flag1 = checkUsername(username);  // 验证用户名格式
            if (!(flag1)){
                System.out.println("用户名格式有误，请重新输入");
                continue;
            }

            // 校验用户名唯一
            boolean flag2 = contain(userList, username);
            if (flag2){
                System.out.println("用户名" + username + "已存在，请重新输入");
            }else {
                System.out.println("用户名" + username + "可用");
                break;
            }
        }


        // 2.键盘录入密码
        while (true) {
            System.out.println("请输入注册密码");
            password = sc.next();
            System.out.println("请再次输入注册密码");
            String againPassword = sc.next();
            if (!password.equals(againPassword)){
                System.out.println("两次密码不一致，请重新输入");
                continue;
            }else {
                System.out.println("两次密码一致，请输入其他数据");
                break;
            }
        }

        // 3. 验证身份证号码
        /*
        * 长度为18；不以0开头；前17位为数字，后一位是数字、X或x */
        while (true) {
            System.out.println("请输入身份证");
            identityCard = sc.next();
            boolean falg = checkIdentityCard(identityCard);
            if (falg) {
                System.out.println("身份证格式正确，请输入其他数据");
                break;
            }else {
                System.out.println("身份证格式有误，请输入重新输入");
                continue;
            }
        }

        // 键盘录入手机号码
        while (true) {
            System.out.println("请输入手机号：");
            phone = sc.next();
            boolean flag = checkPhone(phone);
            if (flag) {
                System.out.println("手机号输入正确");
                break;
            }else {
                System.out.println("手机号输入有误，请重新输入");
            }
        }

        // 用户名、密码，身份证号码、手机号码放到用户对象中；
        User u = new User(username, password, phone, identityCard);
        // 把用户对象添加到集合中；
        userList.add(u);

    }

    public static boolean checkPhone(String phone){
        // 11位，
        if (phone.length() != 11) return false;

        // 不能0开头；
        if (phone.startsWith("0")) return false;

        // 必须是数字
        for (int i = 0; i < phone.length(); i++) {
            char c = phone.charAt(i);
            if (!(c >= '0'  && c <= '9')) return false;
        }

        return true;
    }

    public static boolean checkIdentityCard(String identityCard){
        // 长度为18；
        if (identityCard.length() != 18) return false;

        // 不以0开头；
        if (identityCard.startsWith("0")){
            // 如果以0开头，返回false
            return false;
        }

        // 前17位为数字，
        for (int i = 0; i < identityCard.length()-1; i++) {
            char c = identityCard.charAt(i);
            if(!(c >= '0' && c<='9')) return false;
        }

        // 后一位是数字、X或x
        char endChar= identityCard.charAt(identityCard.length()-1);
        if ((endChar >= '0' && endChar <= '9') || (endChar == 'x') || (endChar == 'X')){
            return true;
        }else {
            return false;
        }
    }

    public static boolean checkUsername(String username) {
        // 用户名长度必须在3~15位之间
        int len = username.length();
        if (len < 3 || len > 15) return false;

        // 只能是字母加数字的组合
        for (int i = 0; i < username.length(); i++) {
            char c = username.charAt(i);
            //  if (!((小写字母) || (大写字母)  || (数字)))
            if (!((c >= 'a' && c <='z') || (c >= 'A' && c <='Z')  || (c >= '0' && c <= '9'))) {
                return false;
            }
        }

        // 不能是纯数字
        int count = 0;
        for (int i = 0; i < username.length(); i++) {
            char c = username.charAt(i);
            //  if (!((小写字母) || (大写字母)  || (数字)))
            if ((c >= 'a' && c <='z') || (c >= 'A' && c <='Z')) {
                count++;  //a123
                break;
            }
        }
        return count > 0;
    }

    public static boolean contain(ArrayList<User> userList, String username){
        // 循环遍历集合得到每一个用户对象
        // 拿着用户对象中的用户名进行比较
        for (int i = 0; i < userList.size(); i++) {
            User user = userList.get(i);
            String rightUsername = user.getUsername();
            if (rightUsername.equals(username)){
                return true;
            }
        }
        return false;
    }

    public static void forgetPassword(ArrayList<User> userList){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名");
        String username = sc.next();
        boolean flag = contain(userList, username);
        if (!flag){
            System.out.println("用户名"+ username + "不存在，请先注册");
            return;
        }

        System.out.println("请输入身份证号码");
        String identityCard = sc.next();
        System.out.println("请输入手机号码");
        String phone = sc.next();

        // 需要把用户对象通过索引先获取出来
        int index = findIndex(userList, username);
        User user = userList.get(index);

        // 比较用户对象中的手机号和身份证号码是否相同
        if (!(user.getIdentityCard().equals(identityCard) && user.getPhone().equals(phone))){
            System.out.println("身份证号码或手机号码输入有误，不能修改密码");
            return;
        }

        // 所有的数据都验证成功，直接修改密码
        String password;
        while (true) {
            System.out.println("请输入新的密码");
            password = sc.next();
            System.out.println("请再次输入新的密码");
            String againPassword = sc.next();
            if (password.equals(againPassword)){
                System.out.println("两次密码输入一致");
                break;
            }else {
                System.out.println("两次密码输入不一致，请重新输入");
                continue;
            }

        }
        // 改密码
        user.setPassword(password);
        System.out.println("密码修改完成");
    }

    public static int findIndex (ArrayList<User> userList, String username) {
        for (int i = 0; i < userList.size(); i++) {
            User user = userList.get(i);
            if (user.getUsername().equals(username)) return i;
        }
        return -1;
    }
    public static String getCode(){
        ArrayList<Character> alphabetList = new ArrayList<>();
        StringBuilder sb = new StringBuilder();
        Random r = new Random();

        // 创建集合存放大小写字母
        for (int i = 0; i < 26; i++) {
            alphabetList.add((char)('a'+i));
            alphabetList.add((char)('A'+i));
        }

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

        // 把一个数字添加到末尾
        int num = r.nextInt(10);
        sb.append(num);

        // 打乱字符串
        char[] charArr = sb.toString().toCharArray();
        // 用随机索引和最后一个索引交换
        int randomIndex = r.nextInt(charArr.length);
        char temp = charArr[randomIndex];
        charArr[randomIndex] = charArr[charArr.length - 1];
        charArr[charArr.length - 1] = temp;
        return new String(charArr);
    }
}

我把老师的代码敲了一遍，老师写的注释，我几乎是写上去了。

老师的思路和我的思路完全不一样，我就是无脑if添加嵌套。最后的功能我是全部实现了，但是代码的阅读性降低了。在编写过程中好多if把我也搞混了。

代码的逻辑是很简单的，对集合的增删改查操作

总结

集合算是存数据的一种方式，因此在Java中数组和集合都可以存放数据。

数组是有长度限制的，反而集合没有。

随后做的项目，我又学到一种新的思考方式，而不是无脑if。

其次是封装思想的应用

// 封装思想的应用
// 我们可以一些零散的数据封装成一个对象
// 以后传递参数的时候，只需要传递一个整体就可以了。不需要传递零散的数据
User userInfo = new User(username, password, null, null);
boolean res = checkUserInfo(userList, userInfo);
if (res){
    System.out.println("登陆成功");
    StudentSystem.startStudentSystem();  // 启动
    break;
}else {
    System.out.println("密码错误，请重新输入");
    if (i == 2) {
        System.out.println("当前账号"+ username + "已锁定");
        // 账号锁定之后，直接结束方法
        return;
    }else {
        System.out.println("用户名或密码错误，还剩下" + (2-i) + "次机会");
    }
}

反而我把密码验证功能写进了用户类算成一个行为。行为就是方法。
User user = userList.get(i);
if (user.getUsername().equals(username)) return i;
}
return -1;
}
public static String getCode(){
ArrayList alphabetList = new ArrayList<>();
StringBuilder sb = new StringBuilder();
Random r = new Random();

    // 创建集合存放大小写字母
    for (int i = 0; i < 26; i++) {
        alphabetList.add((char)('a'+i));
        alphabetList.add((char)('A'+i));
    }

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

    // 把一个数字添加到末尾
    int num = r.nextInt(10);
    sb.append(num);

    // 打乱字符串
    char[] charArr = sb.toString().toCharArray();
    // 用随机索引和最后一个索引交换
    int randomIndex = r.nextInt(charArr.length);
    char temp = charArr[randomIndex];
    charArr[randomIndex] = charArr[charArr.length - 1];
    charArr[charArr.length - 1] = temp;
    return new String(charArr);
}

}


我把老师的代码敲了一遍，老师写的注释，我几乎是写上去了。

老师的思路和我的思路完全不一样，我就是无脑if添加嵌套。最后的功能我是全部实现了，但是代码的阅读性降低了。在编写过程中好多if把我也搞混了。

代码的逻辑是很简单的，对集合的增删改查操作



# 总结

集合算是存数据的一种方式，因此在Java中数组和集合都可以存放数据。

数组是有长度限制的，反而集合没有。

随后做的项目，我又学到一种新的思考方式，而不是无脑if。

其次是封装思想的应用

```java
// 封装思想的应用
// 我们可以一些零散的数据封装成一个对象
// 以后传递参数的时候，只需要传递一个整体就可以了。不需要传递零散的数据
User userInfo = new User(username, password, null, null);
boolean res = checkUserInfo(userList, userInfo);
if (res){
    System.out.println("登陆成功");
    StudentSystem.startStudentSystem();  // 启动
    break;
}else {
    System.out.println("密码错误，请重新输入");
    if (i == 2) {
        System.out.println("当前账号"+ username + "已锁定");
        // 账号锁定之后，直接结束方法
        return;
    }else {
        System.out.println("用户名或密码错误，还剩下" + (2-i) + "次机会");
    }
}

反而我把密码验证功能写进了用户类算成一个行为。行为就是方法。

原文地址：https://blog.csdn.net/qq_45348840/article/details/140155310

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：C语言使用void *类型作为函数传参
下一篇：【前端】HTML+CSS复习记录【4】

普通程序员如何掌握大模型（LLM）：全面学习路线与知识体系，非常详细收藏我这一篇就够了
原谅我的后知后觉，才开始从头写，我是已经上了一阶段大模型的课，也搜集了些资料，并自己做了小部分实践，回过头来，才想开始整理些文章。起初，大家都在写，都在发，我那会在焦虑。自chatgpt爆火以来，AI
阅读更多2024-10-09
新硬盘第一次使用需要怎样做？
虽然硬盘通常在出厂时是全新的，检查一下硬盘的健康程度也是有必要的，因为这样可以确保硬盘没有潜在的缺陷或问题，避免未来数据丢失的风险。首先，要把准备安装硬盘的电脑关机，最好是把电脑也完全切断。如果自己的
阅读更多2024-10-09
源代码如何才能防泄漏？总结十点注意事项
同时，启用托管平台的日志审计功能，监控所有的代码变动记录，确保代码在托管过程中的安全。4. **定期进行代码审计**：通过自动化的代码审计工具和人工审查相结合，企业可以识别出异常的代码活动，防止恶意行
阅读更多2024-10-09
[vue/no-use-v-if-with-v-for] v-for 和 v-if 在同一个元素中的处理方法
在同一个元素上是反模式（antipattern），因为这会导致额外的 DOM 元素渲染和更新，从而影响性能。Vue 建议将数据过滤逻辑放在组件内部处理，而不是在模板中处理。因此，当需要根据某些条件过滤
阅读更多2024-10-09
计算机毕业设计基于Python的智能停车管理系统的设计与实现 Python+Django+Vue 前后端分离附源码讲解文档
本文介绍了一款基于Python的智能停车管理系统，该系统通过实时监控停车位和智能引导驾驶员停车，旨在提高城市停车管理效率和驾驶员停车体验。系统的主要功能包括车位信息管理、预订信息管理、违规记录管理、缴
阅读更多2024-10-09
单路测径仪的详细介绍
蓝鹏测控单路测径仪以光电检测为核心，结合单片机、LED灯、透镜组、CCD芯片、光阑、滤光镜片等精密元件，组成了一个高效的检测系统。具体来说，发射镜头内点光源发出的光通过发射透镜形成平行光视场射向接收镜
阅读更多2024-10-09
架设传奇SF时提示此服务器满员，GEE引擎点开始游戏弹出服务器满员的解决方法
他折腾了半天，一直没进游戏，我当时测试这个版本时并没有这个提示，当然我测试的是单机，于是远程连上服务器看了下，最终找到问题所在，以下和大家说一下解决方法，下次有朋友碰到的时候希望能顺利解决。打开之后我
阅读更多2024-10-09
网络防火墙的主要功能及其弊端
综上所述，网络设置防火墙的重要性不言而喻。防火墙不仅能够防止未授权的访问、阻止恶意软件的传播、防止数据泄露等安全威胁。同时，还能够应对复杂的网络环境。因此，我们应该重视防火墙的设置和管理，在企业当中应
阅读更多2024-10-09
汽车车轮平衡块行业前景：预计2030年全球市场规模将达到10亿美元
汽车车轮平衡块，也称为轮胎平衡块，是一种安装在车轮上的配重部件。许多国家的监管机构都制定了汽车安全标准，其中包括对平衡车轮的要求，从而推动了对车轮平衡重物的需求。环保型车轮平衡重物的开发：由锌、钢和复
阅读更多2024-10-09
鸿蒙NEXT开始公测，哪些机型可以升级？鸿蒙版微信界面简洁
此外从微信鸿蒙测试版的界面截图来看，鸿蒙版的微信 App 界面非常简洁干净。此外，对大家很关心的微信 App 适配鸿蒙 NEXT 系统问题，腾讯公司公关总监于今日发布了回应，表示“微信鸿蒙原生版今日起
阅读更多2024-10-09

javaSE ArrayList&学生管理系统

集合

集合的基本使用

为什么要有集合

ArrayList

构造方法

成员方法

示例代码

案例

ArrayList存储字符串并遍历

ArrayList存储学生对象并遍历

查找用户的索引

添加手机对象并返回要求的数据

学生管理系统

标准版

需求：

分析：

初始菜单：

学生类：

添加功能：

删除功能：

修改功能：

查询功能：

升级版

需求：

分析：

登录界面：

用户类：

注册功能：

登录功能：

忘记密码：

验证码规则：

总结

相关文章