HashSet 源码解析

Set的出现，是为了维持一种元素唯一的集合。HashSet ，是在HashMap的基础之上保持这一特性，并且拥有自身的特点（如果对于HashMap忘了，或者不了解，可以先了解HashMap , 否则，是无法准确地了解HashSet的原理。所以此篇文章是基于了解一些HashMap特性的）

HashSet的特点
在文章的开始，先来说说一些HashSet的特点。
1、遍历耗时与（当前容量 + 总容量）成正比，所以加载因子不宜太低（加载因子简单来说是 “当前容量 / 总容量”的最大值，也就是容器能有多满。如果需要深入了解，可以参考HashMap） , 总容量不宜太大（太大容易造成需要访问许多空位子）

比如有可能想上面这样落位

2、不保证所处位置一只不变（这是当然的，借助HashMap占位，当需要扩容时，各个元素要重新占位）

3、不保证同步，即线程不安全。解决办法如同步代码块或者Set s = Collections.synchronizedSet(new HashSet(…))等

4、支持null

初始化

看初始化前，先要知道两个重要的成员变量，如下

//实际装载元素的容器
private transient HashMap<E,Object> map;

//傀儡元素，用于占位，后面会有解释
private static final Object PRESENT = new Object();

注意到一个细节，map的Key为范型，Value为Object，这里可以猜测可能会与如何存储有关。

看几个构造函数

 public HashSet() {
        map = new HashMap<>();
    }
 public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }
 public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }
 public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

构造函数实际上实行工作的事HashMap，不多做解释

此外注意到有一个特别的构造函数

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

这里依赖的是LinkedHashMap而不是HashMap，LinkedHashMap的特点是每一个Entry持有头尾指针，指向另一个Entry，典型的双向链表。我觉得使用这一种构造是为了提高遍历速度，因为避免了遍历空的位置

常用操作

public int size() {
        return map.size();
    }
public boolean isEmpty() {
        return map.isEmpty();
    }
public boolean contains(Object o) {
        return map.containsKey(o);
    }
public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }
public void clear() {
        map.clear();
    }

可以看到，实际上在做操作的是HashMap，因此不了解HashMap就直接来学HashSet，会本末倒置噢。

维护唯一性
到了这里，还有一个问题，就是HashSet怎么保证元素唯一呢？还记得前面提到的一个傀儡变量PRESENT吗（在初始化小节里），是利用PRESENT和HashMap的特性来维护唯一性的。

此话怎讲？
回看这add()

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

从这里追踪，会走到HashMap的putVal，源码如下

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //获得新元素在数组上的位置，此位置没有被占用直接放入
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //获得新元素在数组上的位置，此位置被占用，放入此位置上的链表
        else {
            Node<K,V> e; K k;
            //hash值相同并且key值相同，说明已经存在此次put为更新操作，更新key对应的value
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //没有找到相同的key，说明不存在，为插入操作，加入到队列尾部
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

由上面HashMap的源码知道，HashSet在加入新元素时，HashMap先进行定位找到元素在数组上的位置，如果这个位置上什么也没有，直接加入；如果有，则加入这个位置上的链表里，如果链表里不巧也有这个元素对应的key，也不会对唯一性造成影响，因为在HashMap的putVal规则中，如果存在key的元素，那么更新此key的value值，而HashSet的每一个元素的value都是那个傀儡元素PRESENT，所以实际上，key对应的值并没有改变，所以保证了唯一性。

实际上也就是说，HashSet，使用了HashMap的每一个元素的Key，来存储自己想要存储的东西。

使用场景
符合如下条件的场景可以考虑使用HashSet
1、保证元素唯一性（不保证唯一还是Set吗0，-）
2、快速存取（毕竟散列表定位）
3、对存储顺序无要求

文章到这里就结束了，其中当然有不够完善的地方，来日有更好的见解会及时更新，如果有错误的地方，欢迎敲敲门 =。=