深入泛型与集合源码分析，带你走进不一样的java世界

最新推荐文章于 2024-10-06 14:11:04 发布

ayualign

最新推荐文章于 2024-10-06 14:11:04 发布

阅读量243

点赞数 1

文章标签： java 数据结构算法列表

本文链接：https://blog.csdn.net/ayualign/article/details/110089955

版权

本文详细介绍了Java集合框架，包括Collection、List、Set、Map等接口及其主要实现类，如ArrayList、HashSet、HashMap等。同时，讨论了泛型的擦拭法实现，指出其限制，并通过代码示例展示了集合的动态扩容机制。此外，还探讨了反射在集合中的应用，揭示了泛型在运行时的类型擦除特性。

摘要由CSDN通过智能技术生成

深入集合与泛型

集合框架图

集合

集合接口

集合框架定义了一些接口。本节提供了每个接口的概述：序号接口描述
1 Collection 接口
Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。
Collection 接口存储一组不唯一，无序的对象。

2 List 接口
List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。
List 接口存储一组不唯一，有序（插入顺序）的对象。

3 Set
Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。
Set 接口存储一组唯一，无序的对象。

4 SortedSet
继承于Set保存有序的集合。

5 Map
Map 接口存储一组键值对象，提供key（键）到value（值）的映射。

6 Map.Entry
描述在一个Map中的一个元素（键/值对）。是一个Map的内部类。

7 SortedMap
继承于 Map，使 Key 保持在升序排列。

8 Enumeration
这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。

集合实现类（集合类）

Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类，这些类可以直接拿来使用，而另外一些是抽象类，提供了接口的部分实现。

标准集合类汇总于下表：

序号类描述
1 AbstractCollection
实现了大部分的集合接口。

2 AbstractList
继承于AbstractCollection 并且实现了大部分List接口。

3 AbstractSequentialList
继承于 AbstractList ，提供了对数据元素的链式访问而不是随机访问。

4 LinkedList
该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：
List list=Collections.synchronizedList(newLinkedList(…));
LinkedList 查找效率低。

5 ArrayList
该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。

6 AbstractSet
继承于AbstractCollection 并且实现了大部分Set接口。

7 HashSet
该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。

8 LinkedHashSet
具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
9 TreeSet
该类实现了Set接口，可以实现排序等功能。

10 AbstractMap
实现了大部分的Map接口。

11 HashMap
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。

12 TreeMap
继承了AbstractMap，并且使用一颗树。

13 WeakHashMap
继承AbstractMap类，使用弱密钥的哈希表。

14 LinkedHashMap
继承于HashMap，使用元素的自然顺序对元素进行排序.

15 IdentityHashMap
继承AbstractMap类，比较文档时使用引用相等。

序号类描述
1 Vector
该类和ArrayList非常相似，但是该类是同步的，可以用在多线程的情况，
该类允许设置默认的增长长度，默认扩容方式为原来的2倍。
2 Stack
栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
3 Dictionary
Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。
4 Hashtable
Hashtable 是 Dictionary(字典) 类的子类，位于 java.util 包中。

5 Properties
Properties 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。
6 BitSet
一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。

集合算法
集合框架定义了几种算法，可用于集合和映射。这些算法被定义为集合类的静态方法。

在尝试比较不兼容的类型时，一些方法能够抛出 ClassCastException异常。当试图修改一个不可修改的集合时，抛出UnsupportedOperationException异常。

集合定义三个静态的变量：EMPTY_SET，EMPTY_LIST，EMPTY_MAP的。这些变量都不可改变。

序号算法描述
1 Collection Algorithms
这里是一个列表中的所有算法实现。

下面通过代码反射得到集合底层进行剖析

package com.zhibang.sk.kqfx;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;

public class ListandFanxing <T>{
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(123);
        list2.add(1232);
        list2.add(3);
        list2.add(999);
//        list2.add(new StringBuffer());
//		list2.add(20);//错误
        Class class1 = list.getClass();
        Class class2 = list2.getClass();
        System.out.println("class1==class2??"+(class1==class2));
        //反射的操作都是编译之后的操作
        /*
         * class1==class2的比较结果返回true说明集合的.class是去除泛型的
         * 也就是说集合编译之后没有了泛型
         * Java中集合的泛型，是防止错误输入的，绕过编译就无效了
         */
        try {
            Method method = class1.getMethod("add", Object.class);
            method.invoke(list2, "我进去了！！！");//反射后可以加进去String型的
            System.out.println(list2.size());
            //绕过编译操作就绕过了泛型
            System.out.println("list2:"+list2);
//
//			//那么就不能使用正常的forEach遍历了 //ClassCastException
//			for(Integer integer:list2){
//				System.out.println(integer);
//			}
            // 需要用到 Object 遍历了
//            for (Object integer : list2) {
//                System.out.println(integer);
//            }
            // 这里通过反射拿到集合底层字段给大家演示
            Field elementData = class2.getDeclaredField("elementData");
            elementData.setAccessible(true);//暴力反射拿到访问权限 破封装
            // java 8 以上 使用这段代表都会报红色警告 这里是正常现象
            Object[] objects = (Object[]) elementData.get(list2);
            // 这里拿到集合的底层 Object 数组 打印
            // 可以看出我们的集合底层就是一个 object数组 然后通过扩容和构造方法实现动态数组
            System.out.println(Arrays.toString(objects));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

通过上述代码可以知道集合的长度是10 可以通过源码进行查看

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

在源码中集合初始化时是无长度的那么他是怎么进行扩容的呢？
通过添加数据的外部方法只有add 那么我们先看看 add方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oMiuOoTR-1606212776517)(C:\Users\hu\AppData\Roaming\Typora\typora-user-images\1606211574798.png)]

实际上集合源码中有3个add 方法 2个public 1个private修饰

private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }
public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }
public void add(int index, E element) {
        rangeCheckForAdd(index);
        modCount++;
        final int s;
        Object[] elementData;
        if ((s = size) == (elementData = this.elementData).length)
            elementData = grow();
        System.arraycopy(elementData, index,
                         elementData, index + 1,
                         s - index);
        elementData[index] = element;
        size = s + 1;
    }

通过源码可以看到这么一个方法 elementData = grow();

grow（）

private Object[] grow() {    
    return grow(size + 1);
}
private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
    }
// 这个方法最终指向 这么一个方法 newCapacity（int minCapacity）
private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//这里得到老长度
        int newCapacity = oldCapacity + (oldCapacity >> 1);
    	//这里可以看作 新长度 等于 老长度扩容50% 1= 1+1x0.5
        if (newCapacity - minCapacity <= 0) {
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return minCapacity;
        }
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
    }

集合的方法进行内部方法调用判断是否扩容从而实现动态扩容

每次数据存储最后一个元素时才进行扩容

扩容长度 = 原来的长度 + （原长x1.5）

泛型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nsYs55sd-1606212776519)(E:\个人资料\个人资料\java笔记\胡煜java整理笔记\集合框架\03_泛型的概念.bmp)]

泛型是一种类似”模板代码“的技术，不同语言的泛型实现方式不一定相同。

Java语言的泛型实现方式是擦拭法（Type Erasure）。

所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。

例如，我们编写了一个泛型类Pair，这是编译器看到的代码：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

而虚拟机根本不知道泛型。这是虚拟机执行的代码：

public class Pair {
    private Object first;
    private Object last;
    public Pair(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

因此，Java使用擦拭法实现泛型，导致了：

编译器把类型<T>视为Object；
编译器根据<T>实现安全的强制转型。

使用泛型的时候，我们编写的代码也是编译器看到的代码：

Pair<String> p = new Pair<>("Hello", "world");
String first = p.getFirst();
String last = p.getLast();

而虚拟机执行的代码并没有泛型：

Pair p = new Pair("Hello", "world");
String first = (String) p.getFirst();
String last = (String) p.getLast();

所以，Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实行安全地强制转型。

了解了Java泛型的实现方式——擦拭法，我们就知道了Java泛型的局限：

局限一：``不能是基本类型，例如int，因为实际类型是Object，Object类型无法持有基本类型：

Pair<int> p = new Pair<>(1, 2); // compile error!
//编译错误

局限二：无法判断带泛型的类型：

Pair<Integer> p = new Pair<>(123, 456);
// Compile error: 编译错误
if (p instanceof Pair<String>) {
    
}

原因和前面一样，并不存在Pair.class，而是只有唯一的Pair.class。

局限三：不能实例化T类型：

public class Pair<T> {
    private T first;
    private T last;
    public Pair() {
        // Compile error:
        //编译错误 
        first = new T();
        last = new T();
    }
}

上述代码无法通过编译，因为构造方法的两行语句：

first = new T();
last = new T();

擦拭后实际上变成了：

first = new Object();
last = new Object();
// 等同于 
String a = new Object(); //x 报错
Integer b = new Object(); //x
// 这种写法是不允许的！！

这样一来，创建new Pair()和创建new Pair()就全部成了Object，显然编译器要阻止这种类型不对的代码。

    //编译错误 
    first = new T();
    last = new T();
}

}


上述代码无法通过编译，因为构造方法的两行语句：

```java
first = new T();
last = new T();

擦拭后实际上变成了：

first = new Object();
last = new Object();
// 等同于 
String a = new Object(); //x 报错
Integer b = new Object(); //x
// 这种写法是不允许的！！

这样一来，创建new Pair()和创建new Pair()就全部成了Object，显然编译器要阻止这种类型不对的代码。
小白理解本文章借用菜鸟以及廖雪峰的理解以及代码给大家便于理解如有侵权，及时联系
希望各位大佬进行点评！！！

ayualign

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫