15.集合框架（对象数组，集合，数据结构）_方法声明功能描述size()获取集合的长度retainall()取两个集合的交集其他功能方-CSDN博客

本文链接：https://blog.csdn.net/weixin_62520626/article/details/121407697

1.对象数组的概述和使用

需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。
       学生：Student
           成员变量：name,age
           构造方法：无参,带参
           成员方法：getXxx()/setXxx()

学生类：

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

    public Student() {
    }

    public Student(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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类：

public class MyTest {
    public static void main(String[] args) {
       /* 需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。
        学生：Student
        成员变量：name, age
        构造方法：无参, 带参
        成员方法：getXxx() / setXxx()
        存储学生的数组 ? 自己想想应该是什么样子的 ?*/

        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);

        //对象数组
        Student[] students=new Student[3];
        students[0]=s1;
        students[1]=s2;
        students[2]=s3;

        for (int i = 0; i < students.length; i++) {
            Student student = students[i];
            String name = student.getName();
            int age = student.getAge();
            System.out.println("姓名："+name+" 年龄："+age);
        }


        //数组作为容器，来存储元素，但是有一些不方便的地方，数组的长度是固定的，一旦定义，就不能改变。
        //有的时候，我们想要往数组中添加元素，或删除元素，就不是很方便了。
        //Java考虑到，我们能够更加容易的操作容器中的元素，给我们提供了另外一种容器，就是集合。
        //集合和数组的区别？
        //数组长度是固定的，一旦定义，就不能改变。
        //集合的长度是可变的。
        //数组既可以存储基本数据类型，也可以存储引用数据类型
        //集合只能存储引用数据类型，
        //数组中的元素，只能是同一种数据类型的元素。
        //集合可以存储不同类型的元素。

    }
}

2.集合的由来及集合继承体系图

1.集合的由来
   面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。
2.数组和集合的区别
   (1): 长度区别:
       数组的长度是固定的而集合的长度是可变的
   (2): 存储数据类型的区别:
       数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
   (3): 内容区别:
       数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素
3.集合继承体系图

3.Collection集合的功能概述

1.Collection的功能概述(通过API查看即可得到)
   a:添加功能
       boolean add(Object obj):添加一个元素
       boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
   b:删除功能
       void clear():移除所有元素
       boolean remove(Object o):移除一个元素
       boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素
       如果没有交集元素则删除失败返回false
   c:判断功能
       boolean contains(Object o)：判断集合中是否包含指定的元素
       boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合包含另一个集合中所有的元素才算包含才返回true)
       比如：1，2，3 containsAll 12=true 1,2,3 containsAll 2,3,4=false
       boolean isEmpty()：判断集合是否为空
   d:获取功能
       Iterator<E> iterator()(重点)
       e:长度功能
           int size():元素的个数
           面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
       f:交集功能
           //例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化
           //A集合对B集合取交集元素，如果没有取到交集元素A集合会被清空
           boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
       g:把集合转换为数组
           Object[] toArray()

add():

public class MyTest {
    public static void main(String[] args) {
        //多态
        Collection collection=new ArrayList();
        //往集合中添加元素 ,添加成功返回true，添加失败返回false Integer  int
        boolean b = collection.add(100);
        System.out.println(b);
        collection.add(200);
        collection.add(300);
        collection.add(Integer.valueOf(400));

        System.out.println(collection);
    }
}

addAll():

public class MyTest2 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");

        Collection list2 = new ArrayList();
        list2.add("AAA");
        list2.add("BBB");
        list2.add("CCC");
        list2.add("DDD");

        //把两个集合中的元素放到一个集合中
        list.addAll(list2);

        System.out.println(list);
        System.out.println(list2);


    }
}

remove()和clear()：

public class MyTest3 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        //删除集合中的元素，删除成功返回true
        boolean b = list.remove("ddd");
        System.out.println(b);
        System.out.println(list);
        //全部清空集合中的元素
        list.clear();
        System.out.println(list);

    }
}

removeAll():

public class MyTest4 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");

        Collection list2 = new ArrayList();
        list2.add("AAA");
        list2.add("BBB");
        list2.add("CCC");
        list2.add("DDD");
        list2.add("ccc");
        list2.add("ddd");

       /* 移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素
        如果没有交集元素 则删除失败 返回false*/
        boolean b = list.removeAll(list2);
        System.out.println(b);
        System.out.println(list);
        System.out.println(list2);
    }
}

把多个对象直接添加到集合中：

public class MyTest5 {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);

        Collection list = new ArrayList();
        list.add(s1);
        list.add(s2);
        list.add(s3);


        System.out.println(list);
    }
}

contains()和isEmpty():

public class MyTest6 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        //判断集合中是否包含该元素
        boolean b = list.contains("aaaaa");
        System.out.println(b);

        list.clear();
        boolean b1 = list.isEmpty(); //判断集合是否为空
        System.out.println(b1);

    }
}

contains（）和size（）：

public class MyTest7 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("AAA");
        list.add("BBB");
        list.add("CCC");
        list.add("DDD");

        Collection list2 = new ArrayList();
        list2.add("AAA");
        list2.add("BBB");
        list2.add("CCC");
        list2.add("DDD");
        list2.add("ccc");
        list2.add("ddd");
        //判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
        // 		比如：1，2，3 containsAll 12=true   1,2,3 containsAll 2,3,4=false
        boolean b = list.containsAll(list2);
        System.out.println(b);

        //获取集合的长度
        int size = list.size();
        System.out.println(size);
    }
}

retainAll（）：取两个集合的交集，放到list集合中，如果集合发生改变，返回true，不改变返回false

public class MyTest8 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add("ccc");
        list.add("ddd");


        Collection list2 = new ArrayList();
        list2.add("AAA");
        list2.add("BBB");
        list2.add("CCC");
        list2.add("DDD");
        list2.add("ccc");
        list2.add("ddd");
        //例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化
        //A集合对B集合取交集元素，如果没有取到交集元素A集合会被清空
        boolean b = list.retainAll(list2);
        System.out.println(b);
        System.out.println(list);
        System.out.println(list2);
    }
}

4.集合的遍历之集合转数组遍历

1.集合的遍历
   toArray() 把一个集合转成数组

   其实就是依次获取集合中的每一个元素。
2.案例演示
   把集合转成数组toArray()，遍历这个数组可以实现集合的遍历

public class MyTest9 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");

        String[] strings = new String[list.size()];

        Iterator iterator = list.iterator();
        int i=0;
        while (iterator.hasNext()){
            String obj = (String) iterator.next();
            strings[i++]=obj;
        }

        System.out.println(Arrays.toString(strings));

        //把集合转换成数组
        Object[] objects = list.toArray();

        for (int j = 0; j < objects.length; j++) {
            String object = (String) objects[j];
            System.out.println(object);
        }
    }
}

5.迭代器的原理及源码解析

public class MyTest91 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        //遍历集合中的元素
        /*
        * java.util
            接口 Iterator<E>
            * 对 collection 进行迭代的迭代器。
            * boolean hasNext()
          如果仍有元素可以迭代，则返回 true。
             E next()
          返回迭代的下一个元素。

        * */
        Iterator iterator = list.iterator();
       // java.util.ArrayList$Itr @1b6d3586
        //Itr是 ArrayList集合的内部类
        //内部类，可以访问外部类的成员，包括私有成员。
        System.out.println(iterator);

        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

6.Collection集合存储自定义对象并遍历

public class MyTest {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(new Student("张三",23));
        list.add(new Student("李四", 24));
        list.add(new Student("王五", 25));
        list.add(new Student("赵六", 26));

        //遍历
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Student student = (Student) iterator.next();
            System.out.println(student.getName()+"==="+student.getAge());
        }
    }
}

7.List概述及特点

List概述及特点: 元素有序,并且每一个元素都存在一个索引.元素可以重复.

8.List集合的特有功能概述和测试

1.List集合的特有功能概述
   void add(int index,E element):   在指定索引处添加元素
   E remove(int index):移除指定索引处的元素返回的是移除的元素
   E get(int index):获取指定索引处的元素
   E set(int index,E element):更改指定索引处的元素返回的而是被替换的元素
   int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
List<E> subList(int fromIndex, int toIndex)
返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图。
2.案例演示:   特有功能测试

指定索引，添加元素：

public class MyTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        //可以在指定索引处，添加元素。
        list.add(0,300);

        System.out.println(list);
    }
}

根据索引，删除元素：

public class MyTest2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        list.add("fff");

        list.remove("aaa"); //根据元素来删掉
        list.remove(0); //根据索引来删除集合中的元素
        System.out.println(list);
    }
}

根据索引，获取元素（ get（））：

public class MyTest3 {
    public static void main(String[] args) {
        //List集合特点：元素有序（存取顺序是一致的），且允许重复元素
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);

        list.remove(0);
        list.remove(Integer.valueOf(200));

        System.out.println(list);

        //根据索引来获取元素
        Object o = list.get(0);
        System.out.println(o);

    }
}

set（），indexof（），lastindexof（）：

public class MyTest4 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("ddd");
        list.add("ddd");
        list.add("eee");
        list.add("fff");
        //根据索引来修改集合中的元素，返回的是你修改之前的旧元素
        Object oldEle = list.set(0, "王老虎");
        System.out.println(oldEle);
        System.out.println(list);

        //返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
        int index = list.indexOf("ddd");

        System.out.println(index);

        int i = list.lastIndexOf("ddd");
        System.out.println(i);
        
    }
}

subList（）：

public class MyTest5 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("ddd");
        list.add("ddd");
        list.add("eee");
        list.add("fff");
        //返回的是 SubList 他ArrayList的一个内部类
        List list1 =list.subList(0, 4);
        list1.add("rrrrr");
        System.out.println(list1);
    }
}

9.List集合存储字符串并遍历（三种遍历方法）：

1.普通迭代器遍历；
2.for循环遍历：
3.list接口中迭代器遍历；

public class MyTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("ddd");
        list.add("ddd");
        list.add("eee");
        list.add("fff");

        //遍历方式1：
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            String next = (String) iterator.next();
            System.out.println(next);
        }
        System.out.println("=====================================");
        //方式2：使用for
        for (int i = 0; i < list.size(); i++) {
            String  o = (String) list.get(i);
            System.out.println(o);
        }
        System.out.println("========================");

        //方式3：使用 List接口中的迭代器
        ListIterator listIterator = list.listIterator();
        //java.util.ArrayList$ListItr@1b6d3586
        System.out.println(listIterator);

        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            System.out.println(next);
        }

    }
}

10.List集合存储学生对象并遍历（三种遍历方法）：

public class MyTest3 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Student("张三", 23));
        list.add(new Student("李四", 24));
        list.add(new Student("王五", 25));

        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Student student = (Student) iterator.next();
            System.out.println(student.getName()+"=="+student.getAge());
        }

        System.out.println("=====================");

        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Student student = (Student) listIterator.next();
            System.out.println(student.getName() + "==" + student.getAge());
        }
        System.out.println("=====================");

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

    }
}

11.ListIterator的特有功能

ListIterator 继承自Iterator 可以使用Iterator中的方法
1.ListIterator的特有功能
boolean hasPrevious(): 是否存在前一个元素
E previous(): 返回列表中的前一个元素
以上两个方法可以实现反向遍历但是注意要完成反向遍历之前要先进行正向遍历这样指针才能移到最后
如果直接反向遍历是没有效果的因为指针默认位置就在最前面他前面没有元素
2.案例演示: ListIterator的特有功能

public class MyTest2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("ddd");
        list.add("ddd");
        list.add("eee");
        list.add("fff");

        //正向迭代
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            System.out.println(next);
        }
        System.out.println("==============================");
        //反向迭代。你先要进行正向迭代。
        while (listIterator.hasPrevious()) {
            Object previous = listIterator.previous();
            System.out.println(previous);

        }
    }
}

12.并发修改异常产生的原因及解决方案

1.案例演示
   需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
2.ConcurrentModificationException出现
   我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合会出现并发修改异常
   原因是我们的迭代依赖与集合当我们往集合中添加好了元素之后获取迭代器那么迭代器已经知道了集合的元素个数
   这个时候你在遍历的时候又突然想给集合里面加一个元素（用的是集合的add方法）那迭代器不同意就报错了
3.解决方案我们用ListIterator迭代器遍历用迭代器自带的add方法添加元素那就不会报错了
   a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
   b:集合遍历元素，集合修改元素

   解决方案2 使用for循环遍历集合添加元素不会报错

当你用迭代器，迭代集合时，在迭代途中，调用集合 的add() remove() 方法来增删元素，就会出现 ConcurrentModificationException 这个异常：

public class MyTest {
    public static void main(String[] args) {
        /*A:
        案例演示
        需求：我有一个集合，请问，我想判断里面有没有 "world" 这个元素，
        如果有，我就添加一个 "javaee" 元素，请写代码实现。*/
        List list = new ArrayList();
        list.add("java");
        list.add("hello");
        list.add("world");

       // modCount++; 记录修改集合的次数
/*
        if (list.contains("world")) {
            list.add("javaee");
        }

        System.out.println(list);*/
        //ConcurrentModificationException
        //当你用迭代器，迭代集合时，在迭代途中，调用集合 的add() remove() 方法来增删元素，就会出现 ConcurrentModificationException 这个异常
       ListIterator iterator = list.listIterator();
        while (iterator.hasNext()) {
            String ele = (String) iterator.next();
             //ele.equal("java")
            if("world".equals(ele)){
                //list.add("javaee");
                iterator.add("javaee");
            }
        }
        //解决方式1：用迭代器遍历，如果你在迭代途中，想要在迭代途中，添加，或删除元素，使用迭代器自带的增删方法

        System.out.println(list);

        //2.for循环，遍历途中可以进行增删元素

        for (int i = 0; i < list.size(); i++) {
            String ele = (String)list.get(i);
            //ele.equal("java")
            if ("world".equals(ele)) {
                //list.add("javaee");
               list.add("javaee");
            }
        }

        System.out.println(list);
    }
}

13.数据结构之栈和队列

1.数据结构概述及常见数据结构
   数据结构其实就是存储数据的格式
   分类:   栈 , 队列 , 数组 , 链表 , 树 , 哈希表图

2.栈特点:    先进后出弹夹

3.队列:    先进先出

14.数据结构之数组和链表

1.数组特点: 查询快 , 增删慢
2.链表特点: 查询慢 , 增删快

public class MyTest {
    public static void main(String[] args) {
        //List 接口下面的 三个实现类
      //  ArrayList: 底层数据结构是数组，查询快，增删慢 ,线程不安全的，效率高
        // Vector: 底层数据结构是数组，查询快，增删慢 线程安全，效率低。
       // LinkedList 底层数据结构是链表，增删快，查询慢，线程不安全效率高



        ArrayList list = new ArrayList();

        list.add("abc");

    }
}

15.List的三个子类的特点

1.List的三个子类的特点 List
   ArrayList:
       底层数据结构是数组，查询快，增删慢。
       线程不安全，效率高。
   Vector:
       底层数据结构是数组，查询快，增删慢。
       线程安全，效率低。
   LinkedList:
       底层数据结构是链表，查询慢，增删快。
       线程不安全，效率高。