DAY03_集合基础ArrayList&综合案例

于 2023-02-21 20:23:00 发布
阅读量120 收藏
点赞数
分类专栏： 2.JavaSE进阶 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57075290/article/details/129133326
版权

目录

1 ArrayList

  • 集合和数组的区别
    • 共同点
      • 都是存储数据的容器
    • 不同点
      • 数组的容量是固定的，集合的容量是可变的
  • 集合的特点

    • 提供一种存储空间可变的存储模型，存储的数据容量可以发生改变

    • 如果存储的数据，长度经常发生改变，推荐使用集合

1.1 ArrayList的构造方法和添加方法

方法名说明
public ArrayList()创建一个空的集合对象
public boolean add(E e)将指定的元素追加到此集合的末尾
public void add(int index,E element)在此集合中的指定位置插入指定的元素
import java.util.ArrayList;

public class Demo1ArrayList {
    /*
        ArrayList构造方法:
                ArrayList() 构造一个初始容量为 10 的空列表。
        成员方法:
            添加:
                boolean add(E e) 将指定的元素添加到此列表的尾部。
                void add(int index, E element) 将指定的元素插入此列表中的指定位置。
        注意:
                集合容器如果没有加入<> 就可以存储任意数据类型
                <> 泛型: 对集合容器存储的数据类型进行限制
     */
    public static void main(String[] args) {
        // 1. 创建集合容器对象
        ArrayList<String> list = new ArrayList<>();
        // 2. 调用对象的add方法, 向容器中添加数据
        list.add("111");
        list.add("222");
        list.add("333");
        list.add("444");
        list.add("555");
        list.add(0,"666");
        System.out.println(list);
    }
}
  • ArrayList集合
    • ArrayList< E >:
      • 可调整大小的数组实现
      • < E >是一种特殊的数据类型，泛型。
    • 怎么用呢 ?
      • 在出现E的地方我们使用引用数据类型替换即可
      • 举例：ArrayList< String >, ArrayList< Student >

1.2ArrayList类常用方法【应用】

成员方法 :

方法名说明
public boolean remove(Object o)删除指定的元素，返回删除是否成功
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 Demo2ArrayList {
    /*
        集合常用成员方法:
            添加:
                boolean add(E e) 将指定的元素添加到此列表的尾部。
                void add(int index, E element) 将指定的元素插入此列表中的指定位置。
            删除:
                public boolean remove(Object o) 删除指定的元素，返回删除是否成功
                public E remove(int index)  删除指定索引处的元素，返回被删除的元素
            修改:
                public E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
            查询:
                public E get(int index) 返回指定索引处的元素
                public int size() 返回集合中的元素的个数
     */
    public static void main(String[] args) {
        testAddRemove();
        testSet();
        testGetSize();
    }

    private static void testGetSize() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add("111");
        list.add("222");
        list.add("333");
        list.add("444");
        list.add("555");
        System.out.println(list);
        System.out.println("----------------------");
        //public E get(int index) 返回指定索引处的元素
        //public int size() 返回集合中的元素的个数
        String s1 = list.get(0);
        String s2 = list.get(1);
        String s3 = list.get(2);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println("----------------------");
        int size = list.size();
        System.out.println(size);
        System.out.println("----------------------");
    }

    private static void testSet() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add("111");
        list.add("222");
        list.add("333");
        list.add("444");
        list.add("555");
        System.out.println(list);
        System.out.println("----------------------");
        //public E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
        String set = list.set(0, "000");
        System.out.println("被修改的元素是:"+set);
        System.out.println(list);
        System.out.println("----------------------");
    }

    private static void testAddRemove() {
        ArrayList<String> list = new ArrayList<>();
        //boolean add(E e) 将指定的元素添加到此列表的尾部。
        //void add(int index, E element) 将指定的元素插入此列表中的指定位置。
        list.add("abc");
        list.add("111");
        list.add("222");
        list.add("333");
        list.add("444");
        list.add(5, "555");
        System.out.println(list);
        System.out.println("----------------------");
        //public boolean remove(Object o) 删除指定的元素，返回删除是否成功
        //public E remove(int index)  删除指定索引处的元素，返回被删除的元素
        boolean b1 = list.remove("abc");
        boolean b2 = list.remove("zzz");
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(list);
        String remove = list.remove(0);
        System.out.println("删除的是：" + remove);
        System.out.println(list);
        System.out.println("----------------------");
    }
}

1.3 ArrayList存储字符串并遍历

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

  • 创建集合对象
  • 往集合中添加字符串对象
  • 遍历集合，首先要能够获取到集合中的每一个元素，这个通过get(intindex)方法实现
  • 遍历集合，其次要能够获取到集合的长度，这个通过size()方法实现
  • 遍历集合的通用格式
import java.util.ArrayList;

public class Test1 {
    /*
        需求：创建一个存储字符串的集合，存储3个字符串元素，使用程序实现在控制台遍历该集合
        思路：
            1. 创建集合对象
            2. 往集合中添加字符串对象
            3. 遍历集合
                  获取到集合中的每一个元素，这个通过get(int index)方法实现
                  获取到集合的长度，这个通过size()方法实现
     */
    public static void main(String[] args) {
        // 1. 创建集合对象
        ArrayList<String> list = new ArrayList<>();
        // 2. 往集合中添加字符串对象
        list.add("张三");
        list.add("李四");
        list.add("王五");
        // 3. 遍历集合
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
    }
}

1.4 ArrayList存储学生对象并遍历

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

  • 定义学生类
  • 创建集合对象
  • 创建学生对象
  • 添加学生对象到集合中
  • 遍历集合，采用通用遍历格式实现
import com.itheima.domain.Student;

import java.util.ArrayList;

public class Test2 {
    /*
        需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
        思路：
            1. 定义学生类
            2. 创建集合对象
            3. 创建学生对象
            4. 添加学生对象到集合中
            5. 遍历集合，采用通用遍历格式实现
     */
    public static void main(String[] args) {
        // 2. 创建集合对象
        ArrayList<Student> list = new ArrayList<>();
        // 3. 创建学生对象
        Student stu1 = new Student("张三1",23);
        Student stu2 = new Student("张三2",23);
        Student stu3 = new Student("张三3",23);
        // 4. 添加学生对象到集合中
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        // 5. 遍历集合，采用通用遍历格式实现
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getName() + "..." + stu.getAge());
        }
    }
}

1.5 键盘录入学生信息到集合

案例需求 :
创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
学生的姓名和年龄来自于键盘录入
实现步骤 :

  • 定义学生类，为了键盘录入数据方便，把学生类中的成员变量都定义为String类型
  • 创建集合对象
  • 键盘录入学生对象所需要的数据
  • 创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
  • 往集合中添加学生对象
  • 遍历集合，采用通用遍历格式实现
import com.itheima.domain.Student;

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

public class Test3 {
    /*
        需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
          学生的姓名和年龄来自于键盘录入
        思路：
            1. 定义学生类
            2. 创建集合对象
            3. 键盘录入学生对象所需要的数据
            4. 创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
            5. 往集合中添加学生对象
            6. 遍历集合，采用通用遍历格式实现
     */
    public static void main(String[] args) {
        // 2. 创建集合对象
        ArrayList<Student> list = new ArrayList<>();
        Student stu1 = getStudent();
        Student stu2 = getStudent();
        Student stu3 = getStudent();
        // 5. 往集合中添加学生对象
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        //  6. 遍历集合，采用通用遍历格式实现
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getName() + "..." + stu.getAge());
        }
    }

    public static Student getStudent() {
        // 3. 键盘录入学生对象所需要的数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生姓名:");
        // next()   nextInt();
        String name = sc.next();
        System.out.println("请输入学生年龄:");
        int age = sc.nextInt();
        // 4. 创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
        Student stu = new Student(name, age);
        return stu;
    }
}

1.6 集合删除元素

案例需求 :
建一个存储String的集合，内部存储（test，张三，李四，test，test）字符串，删除所有的test字符串，删除后，将集合剩余元素打印在控制台
实现步骤 :

  • 创建集合对象
  • 调用add方法，添加字符串
  • 遍历集合，取出每一个字符串元素
  • 加入if判断，如果是test字符串，调用remove方法删除
  • 打印集合元素
import java.util.ArrayList;

public class Test4 {
    /*
        需求：
            创建一个存储String的集合
            内部存储（test，张三，李四，test，test）字符串
            删除所有的test字符串，删除后，将集合剩余元素打印在控制台
        思路：
            1. 创建集合对象
            2. 调用add方法，添加字符串
            3. 遍历集合，取出每一个字符串元素
            4. 加入if判断，如果是test字符串，调用remove方法删除
            5. 打印集合元素
       // 注意: 根据元素进行删除, 只能删除集合中的第一个元素
        list.remove("test");
     */
    public static void main(String[] args) {
        // 1. 创建集合对象
        ArrayList<String> list = new ArrayList<>();
        // 2. 调用add方法，添加字符串
        list.add("test");
        list.add("张三");
        list.add("李四");
        list.add("test");
        list.add("test");
        System.out.println(list);
        // 3. 遍历集合，取出每一个字符串元素
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            // 4. 加入if判断，如果是test字符串，调用remove方法删除
            //if(s.equals("test")){}
            if ("test".equals(s)) {
                list.remove(i);
                i--;
            }
        }
        System.out.println(list);
    }
}

1.7 集合元素筛选

案例需求 :
定义一个方法，方法接收一个集合对象（泛型为Student），方法内部将年龄低于18的学生对象找出，并存入新集合对象，方法返回新集合。
实现步骤 :

  • 定义方法，方法的形参定义为ArrayList list
  • 方法内部定义新集合，准备存储筛选出的学生对象 ArrayList newList
  • 遍历原集合，获取每一个学生对象
  • 通过学生对象调用getAge方法获取年龄，并判断年龄是否低于18
  • 将年龄低于18的学生对象存入新集合
  • 返回新集合
  • main方法中测试该方法
import com.itheima.domain.Student;

import java.util.ArrayList;

public class Test5 {
    /*
        需求：定义一个方法，方法接收一个集合对象（泛型为Student）
            方法内部将年龄低于18的学生对象找出
            并存入新集合对象，方法返回新集合。
        思路：
            1. 定义方法，方法的形参定义为ArrayList<Student> list
            2. 方法内部定义新集合，准备存储筛选出的学生对象 ArrayList<Student> newList
            3. 遍历原集合，获取每一个学生对象
            4. 通过学生对象调用getAge方法获取年龄，并判断年龄是否低于18
            5. 将年龄低于18的学生对象存入新集合
            6. 返回新集合
            7. main方法中测试该方法
     */
    public static void main(String[] args) {
        // 7. main方法中测试该方法
        ArrayList<Student> list = new ArrayList<>();
        Student stu1 = new Student("张三1", 10);
        Student stu2 = new Student("张三2", 10);
        Student stu3 = new Student("张三3", 20);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);

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

    }

    // 1. 定义方法，方法的形参定义为ArrayList<Student> list
    public static ArrayList<Student> getList(ArrayList<Student> list) {
        // 2. 方法内部定义新集合，准备存储筛选出的学生对象 ArrayList<Student> newList
        ArrayList<Student> newList = new ArrayList<>();
        // 3. 遍历原集合，获取每一个学生对象
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            // 4. 通过学生对象调用getAge方法获取年龄，并判断年龄是否低于18
            int age = stu.getAge();
            if (age < 18) {
                //  5. 将年龄低于18的学生对象存入新集合
                newList.add(stu);
            }
        }
        // 6. 返回新集合
        return newList;
    }
}

2. 学生管理系统

2.1 学生管理系统实现步骤

  • 案例需求
    针对目前所学内容，完成一个综合案例：学生管理系统！该系统主要功能如下：
    • 添加学生：通过键盘录入学生信息，添加到集合中
    • 删除学生：通过键盘录入要删除学生的学号，将该学生对象从集合中删除
    • 修改学生：通过键盘录入要修改学生的学号，将该学生对象其他信息进行修改
    • 查看学生：将集合中的学生对象信息进行展示
    • 退出系统：结束程序
  • 实现步骤
    • 定义学生类，包含以下成员变量
      • 学生类： Student成员变量：
      • 学号：sid
      • 姓名：name
      • 年龄：age
      • 生日：birthday
      • 构造方法：
      • 无参构造
      • 带四个参数的构造成员方法：
      • 每个成员变量对应给出get/set方法
    • 学生管理系统主界面的搭建步骤
      • 用输出语句完成主界面的编写
      • 用Scanner实现键盘录入数据
      • 用switch语句完成操作的选择
      • 用循环完成再次回到主界面
    • 学生管理系统的添加学生功能实现步骤
      • 用键盘录入选择添加学生
      • 定义一个方法，用于添加学生
        • 显示提示信息，提示要输入何种信息
        • 键盘录入学生对象所需要的数据
        • 创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
        • 将学生对象添加到集合中（保存）
        • 给出添加成功提示
      • 调用方法
    • 学生管理系统的查看学生功能实现步骤
      • 用键盘录入选择查看所有学生信息
      • 定义一个方法，用于查看学生信息
        • 显示表头信息
        • 将集合中数据取出按照对应格式显示学生信息，年龄显示补充“岁”
      • 调用方法
    • 学生管理系统的删除学生功能实现步骤
      • 用键盘录入选择删除学生信息
      • 定义一个方法，用于删除学生信息
        • 显示提示信息
        • 键盘录入要删除的学生学号
        • 调用getIndex方法，查找该学号在集合的索引
        • 如果索引为-1，提示信息不存在
        • 如果索引不是-1，调用remove方法删除并提示删除成功
      • 调用方法
    • 学生管理系统的修改学生功能实现步骤
      • 用键盘录入选择修改学生信息
      • 定义一个方法，用于修改学生信息
        • 显示提示信息
        • 键盘录入要修改的学生学号
        • 调用getIndex方法，查找该学号在集合的索引
        • 如果索引为-1，提示信息不存在
        • 如果索引不是-1，键盘录入要修改的学生信息
        • 集合修改对应的学生信息
        • 给出修改成功提示
      • 调用方法
    • 退出系统
      • 使用System.exit(0);退出JVM

2.2 学生类的定义

public class Student {
    private String sid; // 学号
    private String name; // 姓名
    private int age; // 年龄
    private String birthday; // 生日

    public Student() {
    }

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

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    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 getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}

2.3 测试类的定义

import com.itheima.domain.Student;

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

public class StudentManager {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 创建集合容器对象
        ArrayList<Student> list = new ArrayList<>();
        lo:
        while (true) {
            // 1. 搭建主界面菜单
            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 choice = sc.next();
            switch (choice) {
                case "1":
                    //System.out.println("添加学生");
                    addStudent(list);
                    break;
                case "2":
                    //System.out.println("删除学生");
                    deleteStudent(list);
                    break;
                case "3":
                    //System.out.println("修改学生");
                    updateStudent(list);
                    break;
                case "4":
                    // System.out.println("查看学生");
                    queryStudents(list);
                    break;
                case "5":
                    System.out.println("感谢您的使用");
                    break lo;
                default:
                    System.out.println("您的输入有误");
                    break;
            }
        }
    }

    // 修改学生的方法
    public static void updateStudent(ArrayList<Student> list) {
        System.out.println("请输入您要修改的学生学号:");
        Scanner sc = new Scanner(System.in);
        String updateSid = sc.next();
        // 3. 调用getIndex方法, 查找该学号在集合中出现的索引位置
        int index = getIndex(list, updateSid);
        // 4. 根据索引判断, 学号在集合中是否存在
        if (index == -1) {
            // 不存在: 给出提示
            System.out.println("查无信息, 请重新输入");
        } else {
            // 存在: 接收新的学生信息
            System.out.println("请输入新的学生姓名:");
            String name = sc.next();
            System.out.println("请输入新的学生年龄:");
            int age = sc.nextInt();
            System.out.println("请输入新的学生生日:");
            String birthday = sc.next();
            // 封装为新的学生对象
            Student stu = new Student(updateSid, name, age, birthday);
            // 调用集合的set方法, 完成修改
            list.set(index, stu);
            System.out.println("修改成功!");
        }
    }

    // 删除学生的方法
    public static void deleteStudent(ArrayList<Student> list) {
        // 1. 给出提示信息 (请输入您要删除的学号)
        System.out.println("请输入您要删除的学生学号:");
        // 2. 键盘接收要删除的学号
        Scanner sc = new Scanner(System.in);
        String deleteSid = sc.next();
        // 3. 调用getIndex方法, 查找该学号在集合中出现的索引位置
        int index = getIndex(list, deleteSid);
        // 4. 根据索引判断, 学号在集合中是否存在
        if (index == -1) {
            // 不存在: 给出提示
            System.out.println("查无信息, 请重新输入");
        } else {
            // 存在:删除
            list.remove(index);
            System.out.println("删除成功!");
        }
    }

    // 查看学生的方法
    public static void queryStudents(ArrayList<Student> list) {
        // 1. 判断集合中是否存在数据, 如果不存在直接给出提示
        if (list.size() == 0) {
            System.out.println("无信息, 请添加后重新查询");
            return;
        }
        // 2. 存在: 展示表头数据
        System.out.println("学号\t\t姓名\t年龄\t生日");
        // 3. 遍历集合, 获取每一个学生对象的信息, 打印在控制台
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getSid() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t\t" + stu.getBirthday());
        }
    }

    // 添加学生的方法
    public static void addStudent(ArrayList<Student> list) {
        Scanner sc = new Scanner(System.in);
        // 1. 给出录入的提示信息
        String sid;
        while (true) {
            System.out.println("请输入学号:");
            sid = sc.next();

            int index = getIndex(list, sid);

            if (index == -1) {
                // sid不存在, 学号可以使用
                break;
            }
        }
        System.out.println("请输入姓名:");
        String name = sc.next();
        System.out.println("请输入年龄:");
        int age = sc.nextInt();
        System.out.println("请输入生日:");
        String birthday = sc.next();
        // 2. 将键盘录入的信息封装为学生对象
        Student stu = new Student(sid, name, age, birthday);
        // 3. 将封装好的学生对象, 添加到集合容器当中
        list.add(stu);
        // 4. 给出添加成功的提示信息
        System.out.println("添加成功!");
    }

    /*
        getIndex : 接收一个集合对象, 接收一个学生学号

        查找这个学号, 在集合中出现的索引位置
     */
    public static int getIndex(ArrayList<Student> list, String sid) {
        // 1. 假设传入的学号, 在集合中不存在
        int index = -1;
        // 2. 遍历集合, 获取每一个学生对象, 准备进行查找
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            // 3. 获取每一个学生对象的学号
            String id = stu.getSid();
            // 4. 使用获取出的学生学号, 和传入的学号(查找的学号)进行比对
            if (id.equals(sid)) {
                // 存在: 让index变量记录正确的索引位置
                index = i;
            }
        }
        return index;
    }
}
_-Mr-sun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础 ArrayList案例
cbdA_ZAI的博客
10-16 310
学习视频： Java入门基础视频教程，Java零基础自学首选黑马程序员Java入门教程（含Java项目和Java真题）_哔哩哔哩_bilibili为了帮助广大对Java有兴趣和立志进入本行业的零基础学员，本套课程由此而生，舍弃了冗长的理论，结合软件公司一个个真实的应用需求，来加强大家对知识的理解和掌握。本课程知识全面透彻，案例极为丰富，阶段课程完结后都配备了综合实战案例，具备大量优雅、高质量的代码供初学者训练，手把手边学边干，清楚，实用！是Java零基础学员极好的入门视频。课程从Java语言的简介到程序开
《java入门第一季》之ArrayList集合小案例
weixin_30641999的博客
05-23 79
案例一：去除集合里面的重复元素 package cn.itcast_04; import java.util.ArrayList; /* * ArrayList去除集合中字符串的重复值(字符串的内容相同) * * 分析： * A:创建集合对象 * B:添加多个字符串元素(包含内容相同的) * C:创建新集合 * D:遍历旧集合,获取得到每一个元素 ...
ArrayList 案例
weixin_45102678的博客
03-22 1223
ArrayList 案例 案例1： 目标：掌握ArrayList的基本使用 需求: 某个班级的考试在系统上进行，成绩大致为：98，77，66，89，79，50，100,现在需要先把成绩低于80分以下的数据去掉 /* 易错点： for (int i = 0; i < score.size(); i++) { if(score.get(i)<80){ score.remove(i); } */ 由于每删除一个元素
ArrayList案例
weixin_44546855的博客
01-21 190
下面是在学习关于集合ArrayList过程中， 使用ArrayList来实现一副扑克牌的洗牌和发牌和看牌的一个流程。 步骤如下： 配置牌 这样一副完整的扑克牌就实现了，存储到ArrayList当中。 洗牌 我们使用集合的工具类中的方法shuffle，来进行随机将牌的顺序打乱。 这样就得到一副无序的牌。 发牌 利用ArrayList集合来实现分配牌 4.看牌 System.out.println(“周润发:”+player1); System.out.println(“刘德华:”+play
day05-集合1
08-04
6. **案例：Collection集合存储学生对象并遍历**： 在实际编程中，我们可以使用集合存储自定义对象，如学生对象。首先定义一个`Student`类，包含姓名和年龄属性，然后创建一个`Collection<Student>`集合，添加多个`...
day05集合1
08-04
"Java集合框架中Collection接口的概述和应用" Collection接口是Java集合框架中最顶层的接口，提供了一个存储空间可变的存储模型，存储的数据容量可以随时发生改变。Collection接口的体系结构图如下所示： ...
Java_day12上课资料.zip
04-01
7. **集合框架**：包括ArrayList、LinkedList、HashSet、HashMap等数据结构，它们提供了一种组织和操作数据的有效方式。 8. **文件与IO流**：Java的输入/输出系统允许程序读写文件，以及进行网络通信，涉及File类、...
Java_day25上课资料.zip
04-01
以上内容仅是根据一般的Java教学大纲推测，实际的【Java_day25上课资料.zip】可能还包含了特定的案例分析、练习题、项目实践或者其他高级主题。为了充分利用这些资源，建议按照资料的结构逐步学习，结合配套视频深入...
JavaSE基础入门视频教程33天之（6） part2
09-08
同样，"day06_18(基础语法)库存案例添加商品信息.avi"、"day06_19(基础语法)库存案例查看库存清单.avi"以及"day06_20(基础语法)库存案例查看库存清单代码实现.avi"则展示了如何使用ArrayList来构建库存管理系统的...
arraylist实例
satanmp的专栏
08-09 352
package test; import java.io.*; import java.util.Random; import java.util.Scanner; import java.util.ArrayList; import java.util.List; public class test { public static void main(Str
ArrayList运用案例
hhhhhaa444的博客
02-04 313
ArrayList 有序：元素存入集合的顺序和取出顺序一致，根据元素的索引标记进行访问数据。 集合中的数据可以重复。 查询效率高，增删效率低，线程不安全 底层用数组实现的存储 常用方法 方法 说明 void add（int index，Object element） 在执行索引位置插入数据 Object set(int index,Object element) 修改制定位置元素 Object get(int index) 返回制定位置的元素 Object remove(in
ArrayList练习案例
baidu_41926409的博客
10-22 564
对于ArrayList的第一个练习代码 package com.demo01; import java.lang.reflect.Array; import java.util.ArrayList; public class bianLi { public static void main(String[] args) { //创建一个空数集 Array...
（笔记）关于集合中ArrayList例子
涂鸦板
11-03 653
最近比较忙 进度较慢但未曾拉下
集合类的ArrayList的应用实例
sd_DENG的博客
10-25 820
import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.*; public class Hello { /** * @param args the command line arguments */ public static void main(Str
【JAVA基础】ArrayList综合案例
Javascript_tsj的博客
10-01 2248
② 提供一个方法，可以接收ArrayList集合，和要搜索的学号，返回搜索到的学生对象信息，并展示。① 定义Student类，定义ArrayList集合存储如上学生对象信息，并遍历展示出来。后台程序需要存储如上学生信息并展示，然后要提供按照学号搜索学生信息的功能。② ：创建3个电影对象，封装相关数据，把3个对象存入到集合中去。某影院系统需要在后台存储上述三部电影，然后依次展示出来。① ：定义一个电影类，定义一个集合存储电影对象。③ ：遍历集合中的3个对象，输出相关信息。集合存储多名学员的成绩。
集合ArrayList案例演示
viczking的博客
04-21 406
  ArrayList存储自定义对象package com.whhp.list01;import java.util.ArrayList;/* * ArrayList存储自定义类型:Student */public class Demo03 {    public staticvoid main(String[] args) {        //1.定义一个集合ArrayList        ...
Java ArrayList集合案例（上课笔记）
crush_oo的博客
01-21 623
ArrayList集合的基础案例
java关于ArrayList编程实例
weixin_44081096的博客
04-06 1591
实例一：ArrayList案例 题目： 现有如下字符串元素：[ “aaa”, “bbb”, “ggg”, “ccc”]，请将所有的元素按顺序存入 ArrayList 集合中，并遍历集合查看存储结果。 题目解决思路 1.创建 ArrayList 集合对象，泛型声明为 String 类型。 2.调用集合的 add 方法，将元素依次存入集合。 3.通过print函数遍历集合，输出结果。 代码实现： package cn.LianXi; import java.util.ArrayList; public cl
JDK8集合基础.pdf
最新发布
04-19
JDK8集合基础是Java编程中不可或缺的一部分，本文档详细介绍了Java集合框架的基础知识，包括集合体系图的理解、迭代器的使用、以及List接口及其重要子类ArrayList的特点和操作。以下是对这些内容的深入解析： 1. **...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值