Set集合底层解析

Zeran

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.因为表中的每个节点都含有beforeafter属性,索引每个节点都有序链接,即形成了有序的双向链表结构

    图解

阅读 372

学而不思则罔,思而不学则殆。

7 声望
2 粉丝
0 条评论

学而不思则罔,思而不学则殆。

7 声望
2 粉丝
文章目录
宣传栏