HashSet源码解读

//继承了AbstractSet类，实现了Set等接口
public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable

成员方法

private transient HashMap<E,Object> map;
private static final Object PRESENT = new 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);
}

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

分析HashSet的添加元素底层是如何实现的

测试代码

Set hasSet = new HashSet();
for (int i = 0; i < 20; i++) {
    hasSet.add(i);
}
System.out.println(hasSet);

Debug进入add方法

第一次add，hasSet.add(1);

//hasSet.add(i);Debug后进入add方法
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
//可以看出，使用到了HashMap的put方法，传入了元素e和PRESENT，PRESENT是一个Object对象
​
//接下来进入put方法查看

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
//可以看出，使用到了hash方法，和putVal方法
​
//接下来进入hash方法查看

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//判断传入的key(要添加的元素i)是否为null，如果是null，返回0
//如果key不为0，局部变量h接收key.hashCode()，与(h>>>16)做异或运算
//详细解读hash方法转移至**HashMap 中如何确定元素的位置**
//接下来进入putVal方法

//hash：Key的hash值
//key：原始Key
//value：要存放的值
//onlylfAbsent：如果true代表不更改现有的值
//evict：如果为false表示table为创建状态
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    //tab:引用当前hashMap的散列表
    //p：表示当前散列表的元素
    //n：表示散列表数组的长度
    //i：表示路由寻址  结果
    Node<K,V>[] tab; Node<K,V> p; int n, i;//辅助变量
    
    //延迟初始化逻辑，第一次调用putVal时会初始化hashMap对象中的最耗费内存的散列表
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;//resize方法对数组进行扩容
    if ((p = tab[i = (n - 1) & hash]) == null)//定位数组下标
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        //前提为tab[i]不为空，也就是说，下标为i的数组空间已被占用
        //p为当前索引位置对应的链表的第一个元素，
        //p.hash == hash  如果p的hash值，和准备添加的k的hash值一样
        //(k = p.key) == key  p为一个Node节点(对象)，其内部有Key和Value，
        //将p节点的Key赋值给局部变量k， k==key 是在判断p节点存储的元素与所要添加的元素是否相等
        //key != null && key.equals(k)  在key不为空的情况下，key与k内容相同
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            //if为真，e指向p，e不再为空，if结束，进入 if (e != null) 返回oldValue
            e = p;
        //if为假，判断p是否为红黑树，如果是，调用 putTreeVal 方法去添加
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        //前面if为假，执行下面代码，
        else {
            for (int binCount = 0; ; ++binCount) {
                //(e = p.next) == null  e被p.next赋值
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //如果循环次数大于8（从0到7），对当前链表进行树化准备
                    //在进行树化时，还进行对表长度的判断，小于64会进行扩容，扩容完毕后不会树化，继续往链表结尾存放节点，直到链表长度大于8并且数组长度大于64
                    //链表第九个节点插入后，才会开始树化，虽然binCount为7（链表长度为8），但是上一行代码，添加了一个新的节点，链表长度加一，所以执行树化方法的时候，链表实际长度为9
                    if (binCount >= TREEIFY_THRESHOLD（8） - 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;
    //每加入一个节点，size就会++，而不是只有添加到数组不同位置size才会++
    //由此，就算一个默认长度为16的数组只有两个下标被占用，其节点数大于12，依旧会扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}