Java-集合框架（刨析源码，深层讲解）_ggbond代码

一、引入

（1） 一方面，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。

（2）另一方面，使用Array存储对象方面具有一些弊端，而Java集合就像一种容器，可以动态地把多个对象的引用放入容器中。

⭕ 数组在内存存储方面的特点：

• 数组初始化以后，长度就确定了。
• 数组声明的类型，就决定了进行元素初始化时的类型。
  比如：String[] arr;int[] arr1;Object[] arr2;

⭕ 数组在存储数据方面的弊端：

• 数组初始化以后，长度就不可变了，不便于扩展。
• 数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。
• 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。
• 数组存储的数据是有序的、可以重复的。---->存储数据的特点单一

二、概述

（1）Java集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。

（2）体系分布：
Java 集合可分为 Collection 和 Map两种体系。

⭕ Collection接口：单列数据，定义了存取一组对象的方法的集合。

（实线表示“继承”，虚线表示“实现”）
● List：元素有序、可重复的集合。–>“动态”数组

• ArrayList
• LinkedList
• Vector

● Set：元素无序、不可重复的集合

• HashSet
• LinkedHashSet
• TreeSet

⭕ Map接口：双列数据，保存具有映射关系“key-value对”的集合

（实线表示“继承”，虚线表示“实现”）
● HashMap
● LinkedHashMap
● TreeMap
● Hashtable
● Properties

三、Collection接口

1. 概述

（1）Collection接口是 List、Set 和 Queue接口的父接口，该接口里定义的方法既可用于操作Set集合，也可用于操作 List 和 Queue 集合。

（2）JDK不提供此接口的任何直接实现，而是提供更具体的子接口（如:Set和List）实现。

（3）在 Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成 Object 类型处理；从JDK 5.0增加了泛型以后，Java 集合可以记住容器中对象的数据类型。

2. 方法

2.1 添加

2.2 获取有效元素的个数

2.3 清空集合

2.4 判断是否是空集合

2.5 判断是否包含某个元素

通过调用元素的equals方法来（挨个）比较判断是否是同一个对象

2.6 删除

通过调用元素的equals方法来判断是否是要删除的某个元素，只会删除找到的第一个元素/删除当前集合里的指定某个子集合，即取当前集合的差集

2.7 取两个集合的交集

把交集的结果存在当前集合中

2.8 判断集合是否相等

2.9 转成对象数组

2.10 获取集合对象的哈希值

2.11 遍历

返回迭代器对象，用于集合遍历

2.12 代码演示

@Test
public void test1(){
        Collection coll = new ArrayList();

        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Date());

        //size():获取添加的元素的个数
        System.out.println(coll.size());//4

        //addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);

        System.out.println(coll.size());//6
        System.out.println(coll);//[AA, BB, 123, Tue Apr 19 22:51:41 CST 2022, 456, CC]

        //clear():清空集合元素
        coll.clear();

        //isEmpty():判断当前集合是否为空
        System.out.println(coll.isEmpty());//true
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

@Test
   public void test2(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
//        Person p = new Person("Jerry",20);
//        coll.add(p);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);
        //1.contains(Object obj):判断当前集合中是否包含obj
        //我们在判断时会调用obj对象所在类的equals()。
        boolean contains = coll.contains(123);
        System.out.println(contains);//true
        System.out.println(coll.contains(new String("Tom")));//true
//        System.out.println(coll.contains(p));//true
        System.out.println(coll.contains(new Person("Jerry",20)));//false 

        //2.containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。
        Collection coll1 = Arrays.asList(123,4567);
        System.out.println(coll.containsAll(coll1));//false
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

@Test
    public void test3(){
        //3.remove(Object obj):从当前集合中移除obj元素。
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        coll.remove(1234);
        System.out.println(coll);//[123, 456, Person@621be5d1, Tom, false]

        coll.remove(new Person("Jerry",20));
        System.out.println(coll);//[123, 456, Person@621be5d1, Tom, false]

        //4. removeAll(Collection coll1):差集：从当前集合中移除coll1中所有的元素。
        Collection coll1 = Arrays.asList(123,456);
        coll.removeAll(coll1);
        System.out.println(coll);//[Person@621be5d1, Tom, false]
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //5.retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
       Collection coll1 = Arrays.asList(123,456,789);
       coll.retainAll(coll1);
       System.out.println(coll);//[123, 456]

        //6.equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。
        Collection coll2 = new ArrayList();
        coll2.add(456);
        coll2.add(123);
        coll2.add(new Person("Jerry",20));
        coll2.add(new String("Tom"));
        coll2.add(false);
        System.out.println(coll.equals(coll2));//false
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

   @Test
    public void test5() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //7.hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());//1412105286

        //8.集合 --->数组：toArray()
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //123
        //456
        //Person@621be5d1
        //Tom
        //false

        //拓展：数组 --->集合:调用Arrays类的静态方法asList()
        List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(list);//[AA, BB, CC]

        List arr1 = Arrays.asList(new int[]{123, 456});
        System.out.println(arr1.size());//1

        List arr2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(arr2.size());//2
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

3. Collection子接口之一：List接口

3.1 概述

（1）鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组。

（2）List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引，即“动态”数组,替换原有的数组。

（3）List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。

（4）JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

3.2 方法

List除了从Collection集合继承的方法外，List 集合里还添加了一些根据索引来操作集合元素的方法。

常用方法总结：

3.2.1 代码演示

@Test
        public void test1(){
            ArrayList list = new ArrayList();
            list.add(123);
            list.add(456);
            list.add("AA");
            list.add(new Person("Tom",12));
            list.add(456);
    
            System.out.println(list);//[123, 456, AA, Person@621be5d1, 456]
    
            //void add(int index, Object ele):在index位置插入ele元素
            list.add(1,"BB");
            System.out.println(list);//[123, BB, 456, AA, Person@621be5d1, 456]
            
            //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
            List list1 = Arrays.asList(1, 2, 3);
            list.addAll(list1);
    //        list.add(list1);
            System.out.println(list.size());//9
    
            //Object get(int index):获取指定index位置的元素
            System.out.println(list.get(0));//123
    
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

  @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);
        //int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1.
        int index = list.indexOf(4567);
        System.out.println(index);//-1

        //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
        System.out.println(list.lastIndexOf(456));//4

        //Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);
        System.out.println(obj);//123
        System.out.println(list);//[456, AA, Person@621be5d1, 456]

        //Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1,"CC");
        System.out.println(list);//[456, CC, Person@621be5d1, 456]

        //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);//[Person@621be5d1, 456]
        System.out.println(list);//[456, CC, Person@621be5d1, 456]
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

 @Test
    public void test3(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");

        //方式一：Iterator迭代器方式
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //123
        //456
        //AA
        

        //方式二：增强for循环
        for(Object obj : list){
            System.out.println(obj);
        }
        //123
        //456
        //AA



        //方式三：普通for循环
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
        //123
        //456
        //AA
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3.3 List实现类之一：ArrayList

3.3.1 概述

⭕ 作为List接口的主要实现类；

⭕ 线程不安全的，效率高；

⭕ 底层使用Object[] elementData存储。

3.3.2 源码分析

⭕ jdk 7：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/766361