HashSet

HashSet 是Set 接口的实现类。看下HashSet 的定义

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

HashSet 是基于 HashMap 来实现的。看下其属性及构造函数

 private transient HashMap<E,Object> map;

 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);
    }

我们着重分析 add() 方法

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

跟进来

  public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

这里 对 key 做了hash 操作，计算出 key 的哈希值。
在跟进来

/**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    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;
            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);
            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;
    }

这个是 Jdk 1.8 中的 HashMap put 操作的核心逻辑。相比之前的1.7 进行了些优化。针对一个链上数据过多的出现的性能问题。利用红黑树的特性进行优化。

一句一句来读：
(1)

 if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

如果 tab 为null。 则调用 resize() 方法进行扩容操作。并且记录tab 的 长度。

（2）

 if ((p = tab[i = (n - 1) & hash]) == null){
      tab[i] = newNode(hash, key, value, null);
 }

这句话说：如果没有 哈希冲突，那么就可以放入数据 tab[i] = newNode(hash, key, value, null); 如果有哈希冲突，那么就执行 else 需要解决哈希冲突。

什么是哈希冲突：
通俗的将 就是 我们 进行了一次 put 操作，算出了我们要在 table 数组中 x 位置 放入这个值，那么下一次再进行put 操作时候，又算出了我们要在table 数组中 x 位置放入这个值，那之前已经放了值，那现在怎么处理的呢？那就是通过链表法 进行 数据的存储。如果出现了哈希冲突，那么新加入的节点放在链表的最后面。

（3）上面已经说了，如果有哈希冲突，执行else 里面的逻辑，看下面的代码

if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                 e = p;

需要判断 两者的 key 是否一样的，因为 HashMap 不能加入重复的键，如果一样，那么就覆盖，如果不一样，那么就先判断是不是 TreeNode 类型的：如果 是TreeNode（TreeNode 里面就是利用了红黑树的特性），如果是红黑树，则直接在树中插入键值对，

else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

否则转向下面

 else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);

                        //链表长度大于8转换为红黑树进行处理
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }

                     //遍历过程中若发现key已经存在直接覆盖value即可
                    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;
    }

如果不是红黑树，那么判断链表长度是否大于8，如果大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作。