HashMap源码解析

原创：转载需注明原创地址 https://www.cnblogs.com/fanerwei222/p/11918123.html

开始!

关于HashMap平时用的多, 面试的时候问的也多, 会问Hash碰撞, Hash表扩容, Hash表的整体实现数据结构, 自己用的时候也会遇到一些问题, 用多个线程去处理HashMap时会发生一点奇怪的东西, 有时候是百思不得其解, 不过确也能知其一二, 之前也看过几遍源码, 但是也是过三两天就忘得差不多了, 现记录下, 便日后方便反复阅读理解.

JDK版本:1.8

HashMap数据结构 : 数组 + 链表 + 红黑树 (JDk1.8)

首先来一张自制的文本数据结构原理图:

 略有粗糙, 不过也能看.

JDk1.8的hashmap由数组+链表+红黑树组成, 数组中的一个元素叫做bucket(桶), 一个桶里面可以有多个节点,桶可由链表或者红黑树组成. 关于何时使用链表, 何时使用红黑树在下面的属性中会有说明.

 首先介绍一下各个属性值, 有默认的, 也有后期需要使用到的.

★ 红黑树有关的三个值

/**
 * The bin count threshold for using a tree rather than list for a
 * bin.  Bins are converted to trees when adding an element to a
 * bin with at least this many nodes. The value must be greater
 * than 2 and should be at least 8 to mesh with assumptions in
 * tree removal about conversion back to plain bins upon
 * shrinkage.
 * 桶的树化阈值, 当一个桶中的节点数量不少于这个值的话,
 * 就从链表转化成红黑树, 桶中所有节点由链表节点转化成红黑树节点
 */
static final int TREEIFY_THRESHOLD = 8;

/**
 * The bin count threshold for untreeifying a (split) bin during a
 * resize operation. Should be less than TREEIFY_THRESHOLD, and at
 * most 6 to mesh with shrinkage detection under removal.
 * 桶由树转化成链表的还原阈值
 * 在扩容的时候,桶中的元素小于这个值的话就会把桶中的红黑树转化(还原,切分)成链表
 */
static final int UNTREEIFY_THRESHOLD = 6;

/**
 * The smallest table capacity for which bins may be treeified.
 * (Otherwise the table is resized if too many nodes in a bin.)
 * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
 * between resizing and treeification thresholds.
 * 哈希表的最小树化容量
 * 当整个哈希表的容量大于这个值, 桶才能进行树形化, 否则桶不会进行树形化
 */
static final int MIN_TREEIFY_CAPACITY = 64;

 其他一些字段介绍:

/**
 * The table, initialized on first use, and resized as
 * necessary. When allocated, length is always a power of two.
 * (We also tolerate length zero in some operations to allow
 * bootstrapping mechanics that are currently not needed.)
 * 数组表
 */
transient HashMap.Node<K,V>[] table;

/**
 * Holds cached entrySet(). Note that AbstractMap fields are used
 * for keySet() and values().
 * 缓存条目集
 */
transient Set<Map.Entry<K,V>> entrySet;

/**
 * The number of key-value mappings contained in this map.
 * map当前的大小
 */
transient int size;

/**
 * The number of times this HashMap has been structurally modified
 * Structural modifications are those that change the number of mappings in
 * the HashMap or otherwise modify its internal structure (e.g.,
 * rehash).  This field is used to make iterators on Collection-views of
 * the HashMap fail-fast.  (See ConcurrentModificationException).
 * modCount用于记录HashMap的修改次数,
 * 在HashMap的put(),get(),remove(),Interator()等方法中,都使用了该属性
 * 由于HashMap不是线程安全的,所以在迭代的时候,会将modCount赋值到迭代器的expectedModCount属性中,然后进行迭代,
 * 如果在迭代的过程中HashMap被其他线程修改了,modCount的数值就会发生变化,
 * 这个时候expectedModCount和ModCount不相等,
 * 迭代器就会抛出ConcurrentModificationException()异常
 */
transient int modCount;

/**
 * The next size value at which to resize (capacity * load factor).
 * 下一个要调整大小的阈值, 这个值会等于 容量 x 负载因子
 * @serial
 */
int threshold;

/**
 * The load factor for the hash table.
 * 扩容所用的负载因子
 * @serial
 */
final float loadFactor;

 我们使用hashmap都是:

Map<String, Object> mymap = new HashMap<String, Object>();

 找到它的构造函数:

/**
 * Constructs an empty <tt>HashMap</tt> with the default initial capacity
 * (16) and the default load factor (0.75).
 * 默认无参构造函数把默认的负载因子给到了 mymap
 */
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

 这样一个HashMap实例mymap就生成了, 我们给mymap中加点东西.

mymap.put("hello", "world");

去到put方法中瞧一瞧, 直接从外部点击进去会到Map接口中的方法, 直接找到在HashMap中的实现,

/**
 * Associates the specified value with the specified key in this map.
 * If the map previously contained a mapping for the key, the old
 * value is replaced.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with <tt>key</tt>, or
 *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
 *         (A <tt>null</tt> return can also indicate that the map
 *         previously associated <tt>null</tt> with <tt>key</tt>.)
 */
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

 先是hash()方法生成key的hash值:

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

再是调用了putVal()方法, 并且最后两个参数的值传了一个false, 一个true, 进去看看:

/**
 * Implements Map.put and related methods.
 *
 * @param hash hash for key 传进来的key的哈希值
 * @param key the key 传进来的key
 * @param value the value to put 传进来的值
 * @param onlyIfAbsent if true, don't change existing value 如果是真, 则不改变已存在的值
 * @param evict if false, the table is in creation mode. 这个值可以给插入后的操作执行的方法提供一个判断
 * @return previous value, or null if none 返回原来key的value值
 */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    /**
     * 此处我传进来的值
     * key : hello
     * value : world
     * onlyIfAbsent : false
     * evict : true
     */
    /**
     * 定义局部变量
     * tab : 局部数组表
     * param : 找到对应i下标的Node
     * tabLength : 局部数组表的长度
     * i : tab的下标
     */
    HashMap.Node<K,V>[] tab;
    HashMap.Node<K,V> param;
    int tabLength, i;
    /**
     * 此时table是一个空数组
     * tab 为null, 执行 resize() 方法(*此方法后续分析)
     */
    if ((tab = table) == null || (tabLength = tab.length) == 0){
        /**
         * 把重新分配的表赋值给tab
         */
        tabLength = (tab = resize()).length;
    }
    /**
     * tab长度-1后与key的hash值得到一个下标赋值给i
     * 获取tab中该下标的值, 如果为null,
     * 则执行newNode()方法生成一个Node节点并且将节点赋值给tab[i]
     */
    if ((param = tab[i = (tabLength - 1) & hash]) == null){
        /**
         * 生成一个Node
         */
        tab[i] = newNode(hash, key, value, null);
    }
    /**
     * 接下来的else分支操作是替换旧值
     */
    else {
        /**
         * 临时节点
         */
        HashMap.Node<K,V> okNode;
        /**
         * 临时key
         */
        K tmpK;
        /**
         * 首先对比 找到的节点的hash值是否和传进来的一致;
         * 如果一致, 继续比较
         * 找到的节点的key值是否和传入的key相等==, 相等判断的是引用地址
         * 如果不相等, 判断一下传入的key是否和找到的节点的key equals,
         * equals方法判断的依据默认也是判断引用地址是否相等, 但是很多类像String,
         * 或者自定义的类, 都有可能重写equals() 方法,
         * 这里加上这么一个判断对传入Object类型的key做了一个是否equals校验的宽容性检查,
         * 如果一个自定义对象, 重写了equals方法, 重写了 hashcode方法, 并且只要该对象的两个实例的id相同,
         * 就判定两个实例相等, 这里就起了关键作用, 因为两个对象实例的引用地址一般都不相等, 除非直接赋值引用.
         *
         * 找到节点的hahs值和传入的hash值相等 而且 找到的节点的key和传入的key也相等,则判定该key存在
         */
        if (param.hash == hash &&
                ((tmpK = param.key) == key || (key != null && key.equals(tmpK))))
        {
            /**
             * 将找到的节点赋给临时节点
             */
            okNode = param;
        }
        /**
         * 继续判断找到的节点是否是树节点,也就是红黑树节点的实例
         */
        else if (param instanceof HashMap.TreeNode)
        {
            /**
             * 如果是红黑树的节点, 则调用putTreeVal()方法更新tab, hash, key, value等需要更新的值
             * 并且返回旧的树节点
             */
            okNode = ((HashMap.TreeNode<K,V>)param).putTreeVal(this, tab, hash, key, value);
        }
        else {
            /**
             * 链表节点的判断和赋值操作
             * 链表操作, 不做过多解释,
             * 嘿嘿, 给自己留点思考的空间吧, 留着以后自己看的时候思考一下
             */
            for (int binCount = 0; ; ++binCount) {
                if ((okNode = param.next) == null) {
                    param.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                    {
                        /**
                         * 链表树形化操作
                         */
                        treeifyBin(tab, hash);
                    }
                    break;
                }
                if (okNode.hash == hash &&
                        ((tmpK = okNode.key) == key || (key != null && key.equals(tmpK))))
                    break;
                param = okNode;
            }
        }
        /**
         * 被返回的树节点, 不是树节点就是链表节点
         */
        if (okNode != null) { // existing mapping for key
            /**
             * 旧节点的值
             */
            V oldValue = okNode.value;
            /**
             * 根据 onlyIfAbsent 值来决定返回的value
             * 如果值没有改变返回的值就是传进来的value自己
             */
            if (!onlyIfAbsent || oldValue == null)
            {
                okNode.value = value;
            }
            /**
             * 空方法
             */
            afterNodeAccess(okNode);
            return oldValue;
        }
    }
    /**
     * 操作数自增1
     */
    ++modCount;
    /**
     * 表的容量自增1之后如果大于要扩容的阈值, 则继续重新计算大小
     */
    if (++size > threshold)
    {
        resize();
    }
    /**
     * 一个空方法, 用户可以自行实现
     */
    afterNodeInsertion(evict);
    /**
     * 此时的值是一个新的值, 所以没有旧的值, 返回null
     */
    return null;
}

那几个空方法:

// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(HashMap.Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(HashMap.Node<K,V> p) { }

到这里put操作就差不多了.

再来看看其他3个构造函数吧!

/**
 * Constructs an empty <tt>HashMap</tt> with the specified initial
 * capacity and the default load factor (0.75).
 *
 * @param  initialCapacity the initial capacity.
 * @throws IllegalArgumentException if the initial capacity is negative.
 * 传入一个初始容量值, 使用默认的负载因子
 */
public HashMap(int initialCapacity) {
    /**
     * 调用的下面的这个构造函数
     */
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/**
 * Constructs an empty <tt>HashMap</tt> with the specified initial
 * capacity and the default load factor (0.75).
 *
 * @param  initialCapacity the initial capacity.
 * @throws IllegalArgumentException if the initial capacity is negative.
 * 传入一个初始容量值, 使用默认的负载因子
 */
public HashMap(int initialCapacity) {
    /**
     * 调用的下面的这个构造函数
     */
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/**
 * Constructs an empty <tt>HashMap</tt> with the specified initial
 * capacity and load factor.
 *
 * @param  initialCapacity the initial capacity
 * @param  loadFactor      the load factor
 * @throws IllegalArgumentException if the initial capacity is negative
 *         or the load factor is nonpositive
 * 传入自定义的初始容量, 传入自定义的负载因子
 */
public HashMap(int initialCapacity, float loadFactor) {
    /**
     * 初始容量不能小于0
     * 否则抛出异常
     */
    if (initialCapacity < 0)
    {
        throw new IllegalArgumentException("Illegal initial capacity: " +
                initialCapacity);
    }
    /**
     * 初始容量如果大于最大允许容量, 则使用最大允许容量
     */
    if (initialCapacity > MAXIMUM_CAPACITY)
    {
        initialCapacity = MAXIMUM_CAPACITY;
    }
    /**
     * 负载因子只能是大于0的浮点数
     * 非法的负载因子会抛出异常
     */
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
    {
        throw new IllegalArgumentException("Illegal load factor: " +
                loadFactor);
    }
    this.loadFactor = loadFactor;
    /**
     * 调用方法计算初始容量的 2 的 幂的值
     * 容量大小只允许为2的倍数
     */
    this.threshold = tableSizeFor(initialCapacity);
}

/**
 * Returns a power of two size for the given target capacity.
 * 对给定的容量, 计算出接近该值2倍大小幂的值
 */
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;
}

/**
 * Constructs a new <tt>HashMap</tt> with the same mappings as the
 * specified <tt>Map</tt>.  The <tt>HashMap</tt> is created with
 * default load factor (0.75) and an initial capacity sufficient to
 * hold the mappings in the specified <tt>Map</tt>.
 *
 * @param   m the map whose mappings are to be placed in this map
 * @throws  NullPointerException if the specified map is null
 * 初始化时直接传入一个map, 使用默认的负载因子
 */
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    /**
     * 将传入的map的条目放进新的map中
     */
    putMapEntries(m, false);
}

/**
 * Implements Map.putAll and Map constructor.
 *
 * @param m the map
 * @param evict false when initially constructing this map, else
 * true (relayed to method afterNodeInsertion).
 */
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    /**
     * 传入map 的大小
     */
    int size = m.size();
    if (size > 0) {
        /**
         * 先看看自身table是不是null
         */
        if (table == null) { // pre-size
            float ft = ((float)size / loadFactor) + 1.0F;
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                    (int)ft : MAXIMUM_CAPACITY);
            if (t > threshold)
                threshold = tableSizeFor(t);
        }
        /**
         * 看看大小是否超过了下一个要调整的大小, 超过了则重新计算
         */
        else if (size > threshold)
        {
            resize();
        }
        /**
         * 使用entrySet遍历并且put
         * entrySet 这里值得追溯一下 , 仔细点可以看到其实没有一个地方显式的设置entrySet的值,
         * 在put操作里面没有找到相关给entrySet设置值的代码, 这里面的值是怎么来的值得追寻
         */
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
            K key = e.getKey();
            V value = e.getValue();
            putVal(hash(key), key, value, false, evict);
        }
    }
}

上面说到entrySet()的值是怎么来的, 其实是从抽象类 AbstractCollection<E> 中的 toString()方法来的;
怎么说呢, 在需要使用entrySet()的时候就会使用到这个方法:

public String toString() {
    Iterator<E> it = iterator();
    if (! it.hasNext())
        return "[]";

    StringBuilder sb = new StringBuilder();
    sb.append('[');
    for (;;) {
        E e = it.next();
        sb.append(e == this ? "(this Collection)" : e);
        if (! it.hasNext())
            return sb.append(']').toString();
        sb.append(',').append(' ');
    }
}

这个方法又会调用 iterator() 方法:

final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
    public final int size()                 { return size; }
    public final void clear()               { HashMap.this.clear(); }
    public final Iterator<Map.Entry<K,V>> iterator() {
        return new EntryIterator();
    }
    public final boolean contains(Object o) {
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry<?,?> e = (Map.Entry<?,?>) o;
        Object key = e.getKey();
        Node<K,V> candidate = getNode(hash(key), key);
        return candidate != null && candidate.equals(e);
    }
    public final boolean remove(Object o) {
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>) o;
            Object key = e.getKey();
            Object value = e.getValue();
            return removeNode(hash(key), key, value, true, true) != null;
        }
        return false;
    }
    public final Spliterator<Map.Entry<K,V>> spliterator() {
        return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
    }
    public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
        Node<K,V>[] tab;
        if (action == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next)
                    action.accept(e);
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }
}

Iterator()方法又会new一个EntryIterator , 所以其实是懒加载返回了下一个节点:

final class EntryIterator extends HashIterator
    implements Iterator<Map.Entry<K,V>> {
    public final Map.Entry<K,V> next() { return nextNode(); }
}

这个藏得有点深!

 今天暂时先到这里!

未完待续...