Set集合底层解析

HashSet

特点

• 允许元素为null
• 元素不可重复
• hashmap(数组+链表+红黑树)
• 不安全
• 无序

扩容机制

1. 如果使用无参构造创建hashset，则第一次执行add操作，会直接初始化一个长度为16的数组，且根据16x0.75的加载因子，会得到一个临界值12，也就是说，这个临界值在后面是真正触发扩容的值，我不等到你满了才扩容，而是当集合元素达到-当前容量*0.75=临界值，去触发扩容，且每次扩容是以2倍的增长,并且计算出临界值。
2. 临界值=当前容量*0.75，这个临界值，不是指的hashmap数组的大小，而是这个集合的大小，hashmap内有一个table数组，而这个数组内的每个下标（索引/元素与）都可能存在链式节点，如果每个链式节点元素/数组的长度大于12，就会触发扩容。

3. 当集合内的元素未达到临界值时，如果这个数组中的某一个节点的链式节点元素>=8时，则会触发转换成红黑树，前提是，如果这个数组的长度达到64个长度，如果未到64个长度，则会再次扩容，扩容机制为--当前数组长度的二倍，并且计算出临界值，当临界值被触发，一样会触发扩容机制，如果这个链式节点>=8,且数组的长度达到64，则会将这一个节点转化为红黑树

   解析

   1.初始化HashSet
   1.1 从源码得知，hashset进行初始化，实际上是初始化了一个hashMap。

   /**
     * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
     * default initial capacity (16) and load factor (0.75).
     */
    public HashSet() {
        map = new HashMap<>();
    }

   2.初始化集合后，进行第一次add操作。

   public boolean add(E e) {
      // 此时，则调用hashmap的put,进行put操作
      // 而PRESENT为全局共享的最终的常量，所以，hashset每次的add，都是进行put操作，key为新增元素的值，value始终是PRESENT
    // private static final Object PRESENT = new Object();
      return map.put(e, PRESENT)==null;
    }

   2.1 根据元素的hash后的值，获得数组的索引

   static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

   2.2 判断元素是否已经存在，是否需要进行扩容，是否是红黑树结构，是否是链表。

   final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        // 定义辅助变量           
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // 1.如果当前表的引用为空或者是长度为空，则进入扩容方法
        // 2.扩容会根据当前默认的长度16进行扩容，并且根据加载因子（0.75）得到临界值（12）
        // 3.此时hash表的长度为16
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 1.根据添加元素计算出来的hash值得到的数组的索引（`&`为按位运算符 就是得到两个值的二进制数后每个数进行 `&` 二进制数只有1或者0，进行比较时 1&1=1，1&0=0,0&0=0）
        // 2.如果计算出来的索引值在table表中的值为空，则直接将元素的hash值，key，value添加到表对应的索引处。  
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            // 如果这个表中的索引对应的元素已存在
            // 1.比较新元素的hash和表中索引的hash是否相等
            // 2.并且 两个对象的key元素是否相等或者是说新元素的key不为空，并且
            // 拿新元素的值（k）和表中存在的值（k）进行equals比较，在这里equals方法
            // 怎样使用，完全由我们来控制，如果重写了equals就是比较对象的值，如果没有重写equals就是比较的对象的地址值
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                // 如果两个元素相等，则将数组中索引的对象赋值。
                e = p;
                // 如果这个table表中已存在的元素，是一颗红黑树，则使用红黑树的方式进行元素的添加。
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                // 如果是一个链表
            else {
                for (int binCount = 0; ; ++binCount) {
                // 如果是一个链表，则进行循环读取，如果这个table索引处的链的节点下一个元素为空
                    if ((e = p.next) == null) {
                    // 如果下一个节点为空，则直接元素的下一个节点为空，则直接创建一个新的节点，将元素的hash,key,value传入。
                        p.next = newNode(hash, key, value, null);
                        // 如果当前链表的长度 >=8
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        // 如果链表的节点长度 >=8 
                        // 1.首先回去判断当前table表的长度是否是64，如果不是64
                        // 则会进行table表的扩容（当前容量+当前容量），并且计算出临界值
                        // 2.如果table表中此链表的长度 >=8 并且 table表的长度已经等于64
                        // 则将table表中的这个索引的链表转换成一颗红黑树
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 如果在查询这条链表的过程中，发现链节点的元素的key和新元素的key相等，则不会添加，直接退出
                    // 这里比较的是table表中索引中的下一个元素，因为索引处第一个元素在上面已经比较过了。
                    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;
    }

   LinkedHashSet

   特点

4. 有序
5. linkedHashMap（数组+双向链表）
6. 不可重复
7. 可以为空

8. 不安全

   扩容机制

   因为linkedHashSet继承自HashSet，固扩容机制等同与HashSet等同与HashMap

   解析说明

   1.在LinkedHashSet中维护了一个hash表和双向链表，且含有head和tail
   2.表中的每个节点都有before和after属性，这样可以形成双向链表。
   3.在添加一个元素时，先求hash值，再求索引，确定该元素table的索引位置，然后将元素添加到双向链表中（如果已经存在，则不可添加，等同hashset）
   4.因为表中的每个节点都含有before和after属性，索引每个节点都有序链接，即形成了有序的双向链表结构

   图解