集合

集合与数组的区别对比

集合基础

集合和数组的特点对比

• 集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
• 集合和数组的区别：共同点：都是存储数据的容器；不同点：数组的容量是固定的，集合的容量是可变的。
• 如果存储的数据，长度经常发生改变，推荐使用集合。

数组的延伸：对象数组

需求：将（张三，23）（李四，24）（王五，25）封装为3个学生对象并存入数组

​ 随后遍历数组，将学生信息输出在控制台

思路：

​ 1.定义学生类准备封装数据

​ 2.动态初始化长度为3的数组，类型为Student类型

​ 3.根据需求创建三个学生对象

​ 4.将学生对象存入数组

​ 5.遍历数组

​ 6.调用对象的getXXX方法获取学生信息，并输出在控制台

 public static void main(String[] args) {

        //1.动态初始化长度为3的数组，类型为Student类型
        Student[] arr = new Student[3];
        //2.根据需求创建三个学生对象
        Student student1 = new Student("张三",23);
        Student student2 = new Student("李四",24);
        Student student3 = new Student("王五",25);
        //3.将学生对象存入数组
        arr[0]=student1;
        arr[1]=student2;
        arr[2]=student3;
        //4.遍历数组
        for (int i = 0; i < arr.length; i++) {
            Student temp = arr[i];
            System.out.println(temp.getName()+temp.getAge());
            //数组中存储的是对象，以上代码简写
            System.out.println(arr[i].getName()+arr[i].getAge());
        }
    }
		//输出
            //张三23
            //李四24
            //王五25

####　ArrayList 集合常用方法

/**
 *
 * ArrayList 常用方法集合
 * 添加：
 *      public boolean add(E e)将指定的元素添加到此列表的尾部
 *      public void add(int index, E element)将指定的元素（element）插入此列表中的指定（index）位置
 * 删除：
 *      public boolean remove(Object o)     删除指定的元素，返回元素是否删除成功//只删除集合用的一个元素
 *      public E remove(int index)           删除指定索引（index）处的元素，返回被删除的元素
 * 修改：
 *      public E set(int index,E element)    修改指定索引（index）处的元素，返回被修改的元素
 * 查询：
 *      public E get(int index)             返回指定索引（index）处的元素
 *      public int size()                   返回集合中元素的个数
 *
 * */

#####　例

public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        //public boolean add(E e)将指定的元素添加到此列表的尾部
        arrayList.add("abc");
        arrayList.add("111");
        arrayList.add("222");
        arrayList.add("333");
        arrayList.add("444");
        System.out.println(arrayList);
    //[abc, 111, 222, 333, 444]

        //public void add(int index, E element)将指定的元素（element）插入此列表中的指定（index）位置
        arrayList.add(2,"666");
        System.out.println(arrayList);
    //[abc, 111, 666, 222, 333, 444]
	
        // public boolean remove(Object o)     删除指定的元素，返回元素是否删除成功
        boolean b1 = arrayList.remove("666");
        boolean b2 = arrayList.remove("888");
        System.out.println(b1);//true
        System.out.println("删除不存在的元素，返回："+b2);//false
        //public E remove(int index)           删除指定索引（index）处的元素，返回被删除的元素（index处的元素）
        String beRemovedElement = arrayList.remove(0);
        System.out.println(beRemovedElement);
    //abc

        //public E set(int index,E element)    修改指定索引（index）处的元素，返回被修改的元素
        arrayList.set(1,"修改完成！");
        System.out.println(arrayList);

        // public E get(int index)             返回指定索引（index）处的元素
        //遍历集合时需要用到这个方法
        System.out.println(arrayList.get(2));
        //public int size()                   返回集合中元素的个数
        System.out.println(arrayList);
        System.out.println("集合中有"+arrayList.size()+"个元素");
    }

ArrayList 集合的遍历

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

思路：

​ 1.创建集合对象

​ 2.往集合中添加字符串对象

​ 3.遍历集合，获取到集合的每一个元素，调用get方法实现

​ 4.遍历集合，要能够获取到集合的长度，通过size方法实现

​ 5.遍历集合的通用格式

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add("张三");
        list.add("李四");
        list.add("小明");
        list.add("小兲");
        //快捷键：集合对象list.fori
        for (int i = 0; i < list.size(); i++) {
            //i：每一个索引值
            String s = list.get(i);
            System.out.println(s);
        }
    }

集合遍历的案例

    /*
    *创建一个存储学生对象的集合，存储三个学生对象，使用程序实现在控制台遍历
    * 1.定义学生类
    * 2.创建集合对象
    * 3.创建学生对象
    * 4.添加学生对象到集合中
    * 5.遍历集合，采用遍历格式实现
    *
    * */
public static void main(String[] args) {
    //1.创建集合对象
        ArrayList<Student>list = new ArrayList<>();
    //2.创建学生对象
        Student stu1 = new Student("张三",23);
        Student stu2 = new Student("李四",24);
        Student stu3 = new Student("小明",25);
    //3.添加学生对象到集合中
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
    //4.遍历集合，采用遍历格式实现
        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s);
            //到这一步打印输出的还是学生对象的内存地址,对象元素以内存地址的形式存在于集合容器中
            //需要调用学生类里的get方法才能实现值的打印
            System.out.println(s.getName()+"....."+s.getAge());
            //以上代码可以简写
        	System.out.println(list.get(i).getName()+"...."+list.get(i).getAge());
        }
    }

键盘录入案例

    /**
    *创建一个存储学生对象的集合，存储三个学生对象，使用程序实现在控制台遍历该集合，学生的姓名和年龄来自于键盘录入
    思路：
     * 1.定义学生类
     * 2.创建集合对象
     * 3.键盘录入学生对象所需要的数据
     * 4.创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
     * 5.添加学生对象到集合中
     * 6.遍历集合，采用遍历格式实现
     *
     *相对上一个案例，唯一的改动就是把原本手动写的学生信息，改成了键盘录入
     * */
public static void main(String[] args) {
	//创建集合对象
        ArrayList<Student>list = new ArrayList<>();
            Student stu1 = getStudent();
            Student stu2 = getStudent();
            Student stu3 = getStudent();
            list.add(stu1);
            list.add(stu2);
            list.add(stu3);
        for (int i = 0; i < list.size(); i++) {
            Student student = list.get(i);
            System.out.println(student.getName()+"....."+student.getAge());
        }
    }
	//键盘录入学生对象所需的数据
    private static Student getStudent() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生姓名：");
        String name = sc.next();
        System.out.println("请输入学生年龄：");
        int age = sc.nextInt();
        Student stu = new Student(name,age);
        return stu;
    }

#####　集合删除元素案例

//创建一个存储String的集合，内部存储字符串，删除指定的字符串，删除后，将剩余的元素打印在控制台
/*
*
* 1.创建集合对象
* 2.调用add方法添加字符串
* 3.遍历集合，取到每一个字符串元素
* 4.加入if判断，遇到指定的字符串调用remove方法删除
* 5.打印集合元素
*
* */

 public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add("abd");
        list.add("abf");
        list.add("abg");
        list.add("abc");
        list.add("abc");
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if ("abc".equals(s)){
                list.remove(i);
                i--;
                //集合中某个元素被删除后，后面的元素会向前移动一位
            }
        }
        System.out.println(list);
    }

集合元素筛选案例

需求：

​ 定义一个方法，方法接收一个集合对象（泛型为Student），方法内部将年龄低于18的学生对象找出并存入新集合对象，方法返回新集合

思路：

​ 1.定义方法，方法的形参定义为ArrayListlist

​ 2.方法内部定义新集合，准备存储筛选出的学生对象ArrayListnewList

​ 3.遍历原集合，获取每一个学生对象

​ 4.通过学生对象的getAge方法获取年龄并判断是否低于18

​ 5.将年龄低于18的学生存入新集合

​ 6.返回新集合

​ 7.main方法中测试该方法

 public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Student stu1 = new Student("张三",21);
        Student stu2 = new Student("张四",17);
        Student stu3 = new Student("张五",19);
        Student stu4 = new Student("张六",16);
        Student stu5 = new Student("张七",15);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        list.add(stu4);
        list.add(stu5);
//        7.main方法中测试该方法
        ArrayList<Student> arrayList = getArrayList(list);
        for (int i = 0; i < arrayList.size(); i++) {
            Student student = arrayList.get(i);
            System.out.println(student.getName()+"...."+student.getAge());
        }
    }
    //    1.定义方法，方法形参为ArrayList<Student> list
    public static ArrayList<Student> getArrayList(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;
    }