【Java源码分析】LinkedHashSet和HashSet源码分析

拼搏现实的明天。 2022-07-19 06:19 300阅读 0赞

类的定义

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable{}

是AbstractSet的子类，实现了Set接口和序列化接口以及克隆接口。

1.  内部实际上是一个HashMap实例。不保证遍历顺序，允许空的元素
2.  添加 删除 Contains和size操作都是常数时间复杂度。但是迭代时间复杂度取决于HashSet中元素个数以及HashMap的容量。所以如果迭代性能 要求比较高的时候不要把初始容量设置的过大或者是将装载因子设置的过小
3.  HashSet不是线程安全的，在多线程环境下需要通过对象锁来进行同步或者使用`Set s = Collections.synchronizedSet(new HashSet(...));`在创建的时候包装为一个线程安全的类
4.  使用迭代器进行迭代访问的时候，如果修改了HashSet的结构，会出现fail-fast现象，也就是抛出`ConcurrentModificationException`的异常。

主要成员变量

static final long serialVersionUID = -5024744406713321676L;
    
    private transient HashMap<E,Object> map;
    
    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();

一个是用来序列化的ID，一个就是本质上使用的HashMap实现的HashSet，另外一个成员变量有些特殊。**由于Set类型是不允许出现重复元素的，而HashSet是用HashMap来实现的，而HashMap是不允许有重复的key。于是将存入HashSet中的实体作为key，存入一个value就可以保证HashSet中的对象唯一性**，这个空的作为值的对象就是这里的PRESENT

构造函数

// 1
    public HashSet() {
        map = new HashMap<>(); // 默认容量16装载因子0.75
    }
    
    // 2
    public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }
    
    // 3
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }
    
    // 4
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }
    
    // 5
    // Constructs a new, empty linked hash set.  (This package private constructor is only used by LinkedHashSet.)
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

前面四个构造函数都比较简单直观，重点是第五个，该方法是其子类`LinkedHashSet`的构造方法，而且其内部实现也是`HashMap`的子类`LinkedHashMap`

主要成员方法

由于内部实现是一个HashMap，所以HashSet的一些主要操作都是通过HashMap来实现的

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
    
    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

比如这里的添加和删除，直接使用的是HashMap 的方法。注意在add的时候判断是否返回空的意义：如果在add的时候该Key已经在HashMap中，那么就会返回PRESENT，进而add操作就返回false，添加失败。这也就保证了只能添加不重复的元素。同理，删除操作中由于HashMap的key是Set中的对象，而value都是一样的PRESENT，所以删除时候如果成功，那么一定会返回PRESENT

克隆操作

public Object clone() {
        try {
            HashSet<E> newSet = (HashSet<E>) super.clone();
            newSet.map = (HashMap<E, Object>) map.clone();
            return newSet;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }

该方法返回了当前Set的一个副本，注意**仅仅是Set的副本，Set中的元素是没有被拷贝的**也就是这里做的是一个**浅拷贝**

序列化和反序列化

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        // Write out any hidden serialization magic
        s.defaultWriteObject();
    
        // Write out HashMap capacity and load factor
        s.writeInt(map.capacity());
        s.writeFloat(map.loadFactor());
    
        // Write out size
        s.writeInt(map.size());
    
        // Write out all elements in the proper order.
        for (E e : map.keySet())
            s.writeObject(e);
    }
    
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();
    
        // Read in HashMap capacity and load factor and create backing HashMap
        int capacity = s.readInt();
        float loadFactor = s.readFloat();
        map = (((HashSet)this) instanceof LinkedHashSet ?
               new LinkedHashMap<E,Object>(capacity, loadFactor) :
               new HashMap<E,Object>(capacity, loadFactor));
    
        // Read in size
        int size = s.readInt();
    
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            E e = (E) s.readObject();
            map.put(e, PRESENT);
        }
    }

序列化和反序列化同样需要注意数据的写入和读取顺序必须是一致的

Linked源码分析

前面在看HashSet的源码的时候，第五个构造函数已经说明如何构建一个LinkedHashSet。其实和LinkedHashMap类似，LinkedHashSet也是在原有的数据基础上添加了一个双向链表保存对象的顺序。不过LinkedHashMap是支持访问顺序和插入顺序设置的(按访问顺序进行配置的时候，常被用来实现LRU功能)，而LinkedHashSet不支持。

类的定义

public class LinkedHashSet<E>
    extends HashSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {}

是HashSet的子类，实现的接口和HashSet不同，这里实现的是Set接口。同样支持序列化和克隆操作。

1.  相对于HashSet，LinkedHashSet最大的特点是遍历顺序是可以预测的（和插入顺序一致），因为在HashSet的基础上添加了一个双向链表，链表维持了实体的插入顺序(重复插入不影响原有顺序)。这种添加双向链表的Set在维持元素顺序方面是很有用的
2.  LinkedHashSet提供了Set类的所有方法且**允许空的元素**,对于add remove contains的操作都时常数时间复杂度，由于需要维护双向链表，所以在性能方面只是比HashSet差一点点。
3.  影响效率的两个因素同样是capacity和loadFractor。**不是线程安全的**所以多线程环境下需要进行同步或者包装
4.  迭代器进行迭代的时候如果出现修改LinkedHashSet结构的行为，将会出现fail-fast

构造函数

// 1
    public LinkedHashSet(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor, true);
    }
    
    // 2
    public LinkedHashSet(int initialCapacity) {
        super(initialCapacity, .75f, true);
    }
    
    // 3
    public LinkedHashSet() {
        super(16, .75f, true);
    }
    
    // 4
    public LinkedHashSet(Collection<? extends E> c) {
        super(Math.max(2*c.size(), 11), .75f, true);
        addAll(c);
    }

注意第一个构造函数的第三个参数，该参数的意义可以直接查看LinkedHashMap的源码。如果该参数为true，那么双向链表的顺序是按访问顺序排列，如果是false,也就是默认情况下，是按插入顺序排列的。

LinkedHashSet的实现很简单，只有构造函数，主要是因为具体的实现代码和父类完全一样，都实现在了HashSet类中。**而且构造函数全部是调用super()的三个参数的构造方法**这个方法在上面也列出来了，就是new一个LinkedHashMap，并且第三个参数设置为true，按访问顺序维护双向链表

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }