【java源码】HashSet、HashMap详解

quiet2333

已于 2024-01-11 16:02:59 修改

阅读量336

点赞数 11

分类专栏： java源码文章标签： java 开发语言

于 2024-01-11 15:47:08 首次发布

本文链接：https://blog.csdn.net/weixin_50934030/article/details/135511594

版权

java源码专栏收录该内容

8 篇文章 0 订阅

订阅专栏

本文详细分析了HashSet如何利用HashMap实现，包括核心成员变量的使用、扩容机制、序列化处理以及构造器和成员方法的工作原理。特别关注了HashMap的构造过程和entrySet、keySet、values方法的实现细节。

摘要由CSDN通过智能技术生成

HashSet底层是HashMap，故本文主要围绕HashMap展开

HashSet 简述（不同之处）

核心成员变量

private transient HashMap<E,Object> map，依托HashMap实现功能。使用transient对数据反序列化的理由同ArrayList中的elementData。
1. 由于扩容机制的存在（尤其是达到阈值就扩容），数组（map底层仍然是Node型数组）内存在不少空元素是常见的情形。因此为了节省空间、提高性能，HashSet也重写了序列化相关的writeObject()和readObject()方法，手动序列化和反序列化存入元素。
private static final Object PRESENT = new Object();，map需要以键值对形式存入，故PRESENT 作为所有键的共同对应值，即起占位作用。

构造器

HashSet(Collection<? extends E> c)，容量在集合大小的4/3倍和16之间取大值。addAll方法是继承父类AbstractCollection的同名方法，通过调用add()方法将集合中的元素逐个加入。

~~这里笔者认为存在bug，后续扩容机制中细说~~
这里由于HashMap的相应构造器中调用了tableSizeFor方法，故最终容量大小仍然是2的幂。具体见后文。

public HashSet(Collection<? extends E> c) {
    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
    addAll(c);
}

HashSet()、HashSet(int initialCapacity)、HashSet(int initialCapacity, float loadFactor)底层为HashMap，故略

成员方法

略

HashMap

entrySet、keySet、values方法及它们用到的内部类EntrySet、KeySet、Values，由于篇幅已单独成文。

https://blog.csdn.net/weixin_50934030/article/details/135348058

核心成员变量

transient Node<K,V>[] table，用于存储键值对
transient Set<Map.Entry<K,V>> entrySet，实际运行类为HashMap.EntrySet，为entrySet方法服务
transient Set<K> keySet ，实际运行类为HashMap.KeySet，为keySet方法服务
transient Collection<V> values，实际运行类为HashMap.Values，为values方法服务

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }
	//重写了hashCode方法
    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {
        ...
    }
    public final boolean equals(Object o) {
        ...
    }
}

构造器

仅以public HashMap(int initialCapacity, float loadFactor)为例，其他构造器较为简单
HashMap采用惰性初始化，将大于初始化值的最小2的幂暂存在threshold属性，在加入元素后才会正常初始化table。
tableSizeFor方法，理解时仅考虑最高有效位即可。其原理即将该位1不断右移（1+2+4+8+16=31），最后+1得到大于原数的最小2的幂。对原数-1是为了避免原数本身就是2的幂。

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
}
static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

成员方法

put(K key, V value)方法，本质是putVal方法。注意，这里不同于Hashtable类，调用了hash方法，对键的哈希值进行了二次处理——将其低16位与其高16位异或以降低碰撞率。

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)
细节如下：
1. (n - 1) & hash，快速取余。因为n始终为2的幂。
2. 元素相等判断为（哈希值相同且键相等）或（经equals比较后相等）
3. 当链表元素（含新加入）>=8则进行树化判断。注意，链表元素计数时不含table上的结点
  加入逻辑：
4. 查找table上的相应位置
  1. 若无元素，则插入
  2. 若冲突，则更新值
  3. 若已有元素但不冲突，则遍历链表查询
    1. 若找到空位置则插入，然后进行树化判断
    2. 若冲突，则更新值
5. 判断是否需要扩容
  注意，由于树化判断机制，每次触发树化判断机制但未满足树化阈值时，会进行resize即扩容，显然是扩容到原容量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;
    //数组不存在或容量为0，则扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //由于n始终为2的幂，故可通过以下方式快速取余，以确定新结点位置并存入。
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    //若存入已有元素
    else {
        Node<K,V> e; K k;
        //（哈希值相同且键相等）或（经equals比较后相等）
        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);
                    //当链表元素（含新加入）>=8则进行树化判断
                    //注意，由于(e = p.next)，故链表元素计数时不含table上的结点。
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //（哈希值相同且键相等）或（经equals比较后相等）则不插入
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // 键已经存在则更新值
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)// 若加入后大于阈值则扩容
        resize();
    //为空方法，目的是留给子类如LinkedHashMap以作他用
    afterNodeInsertion(evict);
    return null;
}

treeifyBin(Node<K,V>[] tab, int hash)，树化判断
细节：
1. 小于树化阈值（64）时默认调用resize方法进行扩容
2. 否则对该链表进行树化

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

扩容方法 resize

resize()方法，实现了对原table的扩容，会返回一个Node<K,V>[]的table。
扩容情形：

原容量不为0
1. 容量已最大则不再扩容
2. 否则容量与阈值均扩为2倍
原容量为0
1. 若阈值不为0，则说明调用构造器时初始化了容量值。故扩容到该值。
2. 否则用默认值初始化容量(16)和阈值(0.75*16)

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    //容量默认为0
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
    	//容量已最大则不再扩容
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //否则容量与阈值均扩为2倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    //容量为0时若阈值不为0，则说明调用构造器时初始化了容量值。故扩容到该值。
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    //容量、阈值均为0，则用默认值初始化容量(16)和阈值(0.75*16)
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //默认容量为0、阈值不为0时未对阈值初始化。这里补充实现。
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    //扩容本质是将原来的所有元素搬到更大的数组中，以下即代码实现，篇幅原因略去
    //这也是为什么新Map中键值对可能会移动位置的原因
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            ...
        }
    }
    return newTab;
}