HashSet底层源码分析-CSDN博客

本文链接：https://blog.csdn.net/qq_41939020/article/details/100526645

HashSet

1、特点
- 无序(添加顺序) 有自己的一套排序机制(hash值)
- 不可重复
2、底层分析
- HashSet底层维护了一个HashMap,HashMap中维护了一个table(这是一个Node类型的数组)
- (table中每一个空间都是一个单向链表结构)

添加方法

1、先计算出当前对象的hash值
2、判断当前数组是否为空，或者长度是否为0，如果成立，则进行初始容量的设置
3、根据当前对象的hash值和数组的长度计算出一个索引值，判断当前索引值位置是否有值
- 如果没有 --> 直接将当前对象封装成Node节点，添加到当前索引位置
- 如果有
  - a. hash值一样
    - 继续判断内容是否一致(equals)
      - 内容一致
        直接覆盖value值
      - 内容不一致
        如果不是树节点，则直接将当前对象链接到单向链表中
        循环判断，当前链表中是否有对象和当前对象一致
        如果有一致的则覆盖value值，如果没有一致的则成功链接到当前链表中
  - b. hash值不一样
    - 就判断当前节点是否是树节点
    - 如果不是树节点，则直接将当前对象链接到单向链表中
    - 循环判断，当前链表中是否有对象和当前对象一致
    - 如果有一致的则覆盖value值，如果没有一致的则成功链接到当前链表中
扩容规则
- a.初始化工作
  - ```
    public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
     }
```
  将负载因子设置为0.75
  table=null
  临界值=0
- b.在第一次添加数据时，会将数组容量设置为16，并且计算出临界值为12:((int)16*0.75)
- c.在超过hash表的临界值时，会先进行添加数据的操作，在进行扩容(扩容规则是原容量的2倍，新的临界值也是原来的2倍)
  if (++size > threshold)
  resize();
- d.扩容完成后，会将旧数组中的数据，转移到新数组中(会重新根据hash值和新数组长度进行计算新的索引位置)
- e.在添加数据时，如果一个桶中的链表长度大于8，并且数组长度达到64，则将当前链表结构变为红黑树结构
  如果当前桶内已经是树结构了，则按照树结构的方式去添加数据
3、源码追踪

 	 //创建对象时，构造器只创建了一个HashMap对象
  	public HashSet() {
         map = new HashMap<>();
     }
     
               
     //添加方法--会调用map中的put方法，值是作为map中的key值出现，value值是一个常量对象
     public boolean add(E e) {
         return map.put(e, PRESENT)==null;
     }
     //map中的添加方法
     public V put(K key, V value) {
         return putVal(hash(key), key, value, false, true);
     }
     //计算当前数据的hash值，并且经过了一些位运算(可以直接将运算后的值看作是数据的hash值)
     static final int hash(Object key) {
         int h;
         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
     }
      final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                    boolean evict) {
         Node<K,V>[] tab; Node<K,V> p; int n, i;
         //判断table是否为空，或者长度是否为0
         if ((tab = table) == null || (n = tab.length) == 0)
             n = (tab = resize()).length;//将table进行了一个初始容量的设置
             
         //(n - 1) & hash 根据数据的hash值计算出一个索引值,并判断当前索引位置是否有值
         //(a. hash一样，索引值肯定一样 b.hash值不一样，索引值也有可能一样)
         if ((p = tab[i = (n - 1) & hash]) == null)
         	//如果没有值，直接进入if，指定添加操作(将当前数据封装成一个Node节点添加到当前数组的空位置)
             tab[i] = newNode(hash, key, value, null);
         //如果该索引位置有值，则进入到else
         else  {
 	        //判断目前数组中的元素和当前要添加的元素hash值是否一致
         	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;
                     }
                     //如果能够执行到此处，说明数组中当前元素的下一个元素是有值，判断下一个元素和新元素是否一致
                     //如果一致，则直接break
                     if (e.hash == hash &&
                         ((k = e.key) == key || (key != null && key.equals(k))))
                         break;
                     //如果不一致，则继续循环，继续往下一个判断
                     p = e;
                 }
             }
             //如果e!=null，说明遇到了相同的元素，用该元素覆盖掉相同元素
             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();//[扩容源码](https://blog.csdn.net/qq_41939020/article/details/100528103)
         afterNodeInsertion(evict);
         return null;
     }