关于后端:ArrayList类

1.ArrayList

汇合和数组的劣势比照：

1. 长度可变
2. 增加数据的时候不须要思考索引，默认将数据增加到开端

1.1 ArrayList 类概述

• 什么是汇合

  ​ 提供一种存储空间可变的存储模型，存储的数据容量能够产生扭转

• ArrayList 汇合的特点

  ​ 长度能够变动，只能存储援用数据类型。

• 泛型的应用

  ​ 用于束缚汇合中存储元素的数据类型

1.2 ArrayList 类罕用办法

1.2.1 构造方法

1.2.2 成员办法

1.2.3 示例代码

public class ArrayListDemo02 {public static void main(String[] args) {
        // 创立汇合
        ArrayList<String> array = new ArrayList<String>();

        // 增加元素
        array.add("hello");
        array.add("world");
        array.add("java");

        //public boolean remove(Object o)：删除指定的元素，返回删除是否胜利
        //        System.out.println(array.remove("world"));
        //        System.out.println(array.remove("javaee"));

        //public E remove(int index)：删除指定索引处的元素，返回被删除的元素
        //        System.out.println(array.remove(1));

        //IndexOutOfBoundsException
        //        System.out.println(array.remove(3));

        //public E set(int index,E element)：批改指定索引处的元素，返回被批改的元素
        //        System.out.println(array.set(1,"javaee"));

        //IndexOutOfBoundsException
        //        System.out.println(array.set(3,"javaee"));

        //public E get(int index)：返回指定索引处的元素
        //        System.out.println(array.get(0));
        //        System.out.println(array.get(1));
        //        System.out.println(array.get(2));
        //System.out.println(array.get(3)); //？？？？？？本人测试

        //public int size()：返回汇合中的元素的个数
        System.out.println(array.size());

        // 输入汇合
        System.out.println("array:" + array);
    }
}

1.3 ArrayList 存储字符串并遍历

1.3.1 案例需要

​ 创立一个存储字符串的汇合，存储 3 个字符串元素，应用程序实现在控制台遍历该汇合

1.3.2 代码实现

public class ArrayListDemo3 {public static void main(String[] args) {
        //1. 创立汇合对象
        ArrayList<String> list = new ArrayList<>();

        //2. 增加元素
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");

        //3. 遍历
        // 快捷键: list.fori 正向遍历
        //list.forr 倒着遍历
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
            //i 顺次示意汇合外面的每一个索引

            if(i == list.size() - 1){
                // 最大索引
                System.out.print(list.get(i));
            }else{
                // 非最大索引
                System.out.print(list.get(i) + ",");
            }
        }
        System.out.print("]");
    }
}

1.4 ArrayList 存储学生对象并遍历

1.4.1 案例需要

​ 创立一个存储学生对象的汇合，存储 3 个学生对象，应用程序实现在控制台遍历该汇合

1.4.2 代码实现

public class ArrayListDemo4 {public static void main(String[] args) {
        //1. 创立汇合对象，用来存储数据
        ArrayList<Student> list = new ArrayList<>();

        //2. 创立学生对象
        Student s1 = new Student("zhangsan",16);
        Student s2 = new Student("lisi",15);
        Student s3 = new Student("wangwu",18);

        //3. 把学生对象增加到汇合中
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //4. 遍历
        for (int i = 0; i < list.size(); i++) {
            //i 顺次示意汇合中的每一个索引
            Student stu = list.get(i);
            System.out.println(stu.getName() + "," + stu.getAge());
        }



    }
}

1.5 查找用户的索引

需要：

1，main 办法中定义一个汇合，存入三个用户对象。

用户属性为：id，username，password

2，要求：定义一个办法，依据 id 查找对应的学生信息。

如果存在，返回索引

如果不存在，返回 -1

代码示例：

public class ArrayListDemo6 {public static void main(String[] args) {
        /* 需要：1，main 办法中定义一个汇合，存入三个用户对象。用户属性为：id，username，password
        2，要求：定义一个办法，依据 id 查找对应的学生信息。如果存在，返回索引
        如果不存在，返回 -1*/


        //1. 创立汇合对象
        ArrayList<User> list = new ArrayList<>();

        //2. 创立用户对象
        User u1 = new User("001", "zhangsan", "123456");
        User u2 = new User("002", "lisi", "1234");
        User u3 = new User("003", "wangwu", "1234qwer");

        //3. 把用户对象增加到汇合当中
        list.add(u1);
        list.add(u2);
        list.add(u3);

        //4. 调用办法，通过 id 获取对应的索引
        int index = getIndex(list, "001");

        System.out.println(index);

    }


    //1. 我要干嘛？依据 id 查找对应的学生信息
    //2. 我干这件事件须要什么能力实现？汇合 id
    //3. 办法的调用处是否须要持续应用办法的后果？// 要用必须返回，不要用能够返回也能够不返回
    // 明确阐明须要有返回值 int
    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;}
        }
        // 因为只有当汇合外面所有的元素都比拟完了，能力判定 id 是不存在的。return -1;
    }
}

1.6 判断用户的是否存在

public class ArrayListDemo5 {public static void main(String[] args) {
       /* 需要：1，main 办法中定义一个汇合，存入三个用户对象。用户属性为：id，username，password
        2，要求：定义一个办法，依据 id 查找对应的学生信息。如果存在，返回 true
        如果不存在，返回 false*/

        //1. 定义汇合
        ArrayList<User> list = new ArrayList<>();

        //2. 创建对象
        User u1 = new User("001","zhangsan","123456");
        User u2 = new User("002","lisi","12345678");
        User u3 = new User("003","wangwu","1234qwer");

        //3. 把用户对象增加到汇合当中
        list.add(u1);
        list.add(u2);
        list.add(u3);

        //4. 调用办法，查问 id 是否存在
        boolean result = contains(list, "001");
        System.out.println(result);

    }

    // 定义在测试类中的办法须要加 static
    //1. 我要干嘛？我要依据 id 查问学生是否存在
    //2. 我干这件事件，须要什么能力实现？汇合 id
    //3. 办法的调用处是否须要应用办法的后果？// 如果要用，必须返回，如果不必，能够返回也能够不返回
    // 然而本题明确阐明须要返回
    public static boolean contains(ArrayList<User> list, String id){
        // 循环遍历汇合，失去汇合外面的每一个元素
        // 再进行判断

        for (int i = 0; i < list.size(); i++) {//i 索引  list.get(i); 元素
            User u = list.get(i);
            // 判断 id 是否存在，我是拿着谁跟谁比拟
            // 须要把用户对象外面的 id 拿进去再进行比拟。String uid = u.getId();
            if(id.equals(uid)){return true;//return 关键字：作用就是完结办法。}
        }
        // 只有当汇合外面所有的元素全副比拟结束能力认为是不存在的。return false;
    }

}

2. 学生管理系统

2.1 学生管理系统实现步骤

• 案例需要

  ​ 针对目前咱们的所学内容，实现一个综合案例：学生管理系统。该零碎次要性能如下：

  ​ 增加学生：通过键盘录入学生信息，增加到汇合中

  ​ 删除学生：通过键盘录入要删除学生的学号，将该学生对象从汇合中删除

  ​ 批改学生：通过键盘录入要批改学生的学号，将该学生对象其余信息进行批改

  ​ 查看学生：将汇合中的学生对象信息进行展现

  ​ 退出零碎：完结程序

• 实现步骤

  1. 定义学生类，蕴含以下成员变量

     ​ private String sid // 学生 id

     ​ private String name // 学生姓名

     ​ private String age // 学生年龄

     ​ private String address // 学生所在地

  2. 学生管理系统主界面的搭建步骤

     2.1 用输入语句实现主界面的编写
     2.2 用 Scanner 实现键盘输入
     2.3 用 switch 语句实现抉择的性能
     2.4 用循环实现性能完结后再次回到主界面

  3. 学生管理系统的增加学生性能实现步骤

     3.1 定义一个办法，接管 ArrayList<Student> 汇合
     3.2 办法内实现增加学生的性能
     ​ ①键盘录入学生信息
     ​ ②依据录入的信息创立学生对象
     ​ ③将学生对象增加到汇合中
     ​ ④提醒增加胜利信息
     3.3 在增加学生的选项里调用增加学生的办法

  4. 学生管理系统的查看学生性能实现步骤

     4.1 定义一个办法，接管 ArrayList<Student> 汇合
     4.2 办法内遍历汇合，将学生信息进行输入
     4.3 在查看所有学生选项里调用查看学生办法

  5. 学生管理系统的删除学生性能实现步骤

     5.1 定义一个办法，接管 ArrayList<Student> 汇合
     5.2 办法中接管要删除学生的学号
     5.3 遍历汇合，获取每个学生对象
     5.4 应用学生对象的学号和录入的要删除的学号进行比拟, 如果雷同，则将以后学生对象从汇合中删除
     5.5 在删除学生选项里调用删除学生的办法

  6. 学生管理系统的批改学生性能实现步骤

     6.1 定义一个办法，接管 ArrayList<Student> 汇合
     6.2 办法中接管要批改学生的学号
     6.3 通过键盘录入学生对象所需的信息，并创建对象
     6.4 遍历汇合，获取每一个学生对象。并和录入的批改学生学号进行比拟. 如果雷同，则应用新学生对象替换以后学生对象
     6.5 在批改学生选项里调用批改学生的办法

  7. 退出零碎

     应用 System.exit(0); 退出 JVM

2.2 学生类的定义

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

     // 上面是空参，有参，get 和 set 办法
}

2.3 测试类的定义

public class StudentSystem {public static void main(String[] args) {ArrayList<Student> list = 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("请输入您的抉择：");
            Scanner sc = new Scanner(System.in);
            String choose = sc.next();
            switch (choose) {case "1" -> addStudent(list);
                case "2" -> deleteStudent(list);
                case "3" -> updateStudent(list);
                case "4" -> queryStudent(list);
                case "5" -> {System.out.println("退出");
                    //break loop;
                    System.exit(0);// 进行虚拟机运行
                }
                default -> System.out.println("没有这个选项");
            }
        }
    }

    // 增加学生
    public static void addStudent(ArrayList<Student> list) {
        // 利用空参结构先创立学生对象
        Student s = new Student();

        Scanner sc = new Scanner(System.in);
        String id = null;
        while (true) {System.out.println("请输出学生的 id");
            id = sc.next();
            boolean flag = contains(list, id);
            if(flag){
                // 示意 id 曾经存在，须要从新录入
                System.out.println("id 曾经存在，请从新录入");
            }else{
                // 示意 id 不存在，示意能够应用
                s.setId(id);
                break;
            }
        }

        System.out.println("请输出学生的姓名");
        String name = sc.next();
        s.setName(name);

        System.out.println("请输出学生的年龄");
        int age = sc.nextInt();
        s.setAge(age);

        System.out.println("请输出学生的家庭住址");
        String address = sc.next();
        s.setAddress(address);


        // 把学生对象增加到汇合当中
        list.add(s);

        // 提醒一下用户
        System.out.println("学生信息增加胜利");
    }

    // 删除学生
    public static void deleteStudent(ArrayList<Student> list) {Scanner sc = new Scanner(System.in);
        System.out.println("请输出要删除的 id");
        String id = sc.next();
        // 查问 id 在汇合中的索引
        int index = getIndex(list, id);
        // 对 index 进行判断
        // 如果 -1，就示意不存在，完结办法，回到初始菜单
        if(index >= 0){
            // 如果大于等于 0 的，示意存在，间接删除
            list.remove(index);
            System.out.println("id 为：" + id + "的学生删除胜利");
        }else{System.out.println("id 不存在，删除失败");
        }
    }

    // 批改学生
    public static void updateStudent(ArrayList<Student> list) {Scanner sc = new Scanner(System.in);
        System.out.println("请输出要批改学生的 id");
        String id = sc.next();

        int index = getIndex(list, id);

        if(index == -1){System.out.println("要批改的 id" + id + "不存在，请从新输出");
            return;
        }

        // 当代码执行到这里，示意什么？示意以后 id 是存在的。// 获取要批改的学生对象
        Student stu = list.get(index);

        // 输出其余的信息并批改
        System.out.println("请输出要批改的学生姓名");
        String newName = sc.next();
        stu.setName(newName);

        System.out.println("请输出要批改的学生年龄");
        int newAge = sc.nextInt();
        stu.setAge(newAge);

        System.out.println("请输出要批改的学生家庭住址");
        String newAddress = sc.next();
        stu.setAddress(newAddress);

        System.out.println("学生信息批改胜利");


    }


    // 查问学生
    public static void queryStudent(ArrayList<Student> list) {if (list.size() == 0) {System.out.println("以后无学生信息，请增加后再查问");
            // 完结办法
            return;
        }

        // 打印表头信息
        System.out.println("id\t\t 姓名 \t 年龄 \t 家庭住址");
        // 当代码执行到这里，示意汇合中是有数据的
        for (int i = 0; i < list.size(); i++) {Student stu = list.get(i);
            System.out.println(stu.getId() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t" + stu.getAddress());
        }
    }


    // 判断 id 在汇合中是否存在
    public static boolean contains(ArrayList<Student> list, String id) {
        // 循环遍历汇合失去外面的每一个学生对象
        /*for (int i = 0; i < list.size(); i++) {
            // 拿到学生对象后，获取 id 并进行判断
            Student stu = list.get(i);
            String sid = stu.getId();
            if(sid.equals(id)){
                // 存在，true
                return true;
            }
        }
        // 不存在 false
        return false;*/
       return getIndex(list,id) >= 0;
    }

    // 通过 id 获取索引的办法
    public static int getIndex(ArrayList<Student> list, String id){
        // 遍历汇合
        for (int i = 0; i < list.size(); i++) {
            // 失去每一个学生对象
            Student stu = list.get(i);
            // 失去每一个学生对象的 id
            String sid = stu.getId();
            // 拿着汇合中的学生 id 跟要查问的 id 进行比拟
            if(sid.equals(id)){
                // 如果一样，那么就返回索引
                return i;
            }
        }
        // 当循环完结之后还没有找到，就示意不存在，返回 -1.
        return -1;
    }
}