HashMap漫谈(2)

HashMap原理解析–JDK1.8

在前面的文章中,我介绍了JDK1.7中HashMap的实现原理,这篇文章中,我将继续介绍在JDK1.8中的实现机理,从JDK1.7到JDK1.8中,HashMap的实现中经历了较大的优化(当然源码也更长,看起来更复杂),通过对数据结构的灵活应用,提高了这个稍微复杂数据结构的性能。本文中维持和上篇介绍JDK1.7中HashMap实现原理相同的结构来介绍,JDK1.8中HashMap的原理,包括基本数据结构,构造函数,put get方法等介绍。

基本数据结构

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; }

    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

JDK1.8中,使用了Node<K,V>作为基本数据结构,仔细来看这个数据结构,似乎是和JDK1.7中的Entry相同,只是换了个名字,这里我们暂时认为是一样的,那么HashMap的大体结构应该是这样的

HashMap漫谈(2)

构造方法

虽然jdk的版本变化,但是我们用户初始化的方式是没有变化的,仍然是通过这个方法实现

Map map = new HashMap()

所以使用的依然是无参的构造方法,在1.8中,这个方法的实现如下

public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

这里,我们看到,这个构造函数并没有调用有参方法,只是对负载因数进行了设置。那么对于table的初始化就需要继续往下看。

put方法

接下来我们依照惯例来看一看put方法,该方法直接调用了putVal方法,具体实现如下:

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

我们重点来看putVal方法:

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        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;
                }
                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;
}

我们会发现,这个代码要比1.7中要复杂的多,我们就知道这个HashMap绝对没有那么简单。不过虽然复杂,但是总体的流程是和1.7相同的,总体步骤为:

1、当桶数组 table 为空时,通过扩容的方式初始化 table
2、查找要插入的键值对是否已经存在,存在的话根据条件判断是否用新值替换旧值
3、如果不存在,则将键值对链入链表中,并根据链表长度决定是否将链表转为红黑树
4、判断键值对数量是否大于阈值,大于的话则进行扩容操作

这里我把1.7的put流程放在这里进行比较:

1、如果bucket数组为空,调用inflateTable方法完成初始化;
2、判断待插入key是否为null:
 key == null成立,调用putForNullKey方法完成数据插入,由此可以看出,HashMap的key是可以为null的;
 key == null不成立,跳转到步骤3;
3、计算带插入key的hashCode;
4、根据hashCode按位与计算出所在bucket数组中的位置i;
5、遍历挂在bucket中位置i下的Entry链表,如果当前key已存在,更新它所对应的oldValue为value,并返回oldValue,否则,跳转到步骤6;
6、将key-value插入对应bucket中位置i下的Entry链表中,返回null。

我们把这个流程稍微整理一下,屏蔽一下细节的操作,也可以写成:

1、当桶数组 table 为空时,通过扩容的方式初始化 table
2、查找要插入的键值对是否已经存在,存在的话根据条件判断是否用新值替换旧值
3、如果不存在,则将键值对链入链表中
4、判断键值对数量是否大于阈值,大于的话则进行扩容操作

我们发现除了第3条的半句话,其他的内容都是相同的,这句话也正是JDK1.8中HashMap的实现变复杂的原因,在,JDK1.8中,为了增加查找的性能,在实现HashMap中,对于hash值相同的Node,当个数比较少时,还是采用原来的链表形式来存储,然而,当Node个数多个某个阈值时,会以红黑树的方式进行存储。这是一种比较特殊的平衡二叉树,在后面的文章中我可能会详细介绍这种数据结构,但是这篇文章的重点是介绍HashMap,我们给出一个连接来介绍红黑树,完全没概念的同学可以暂时先看这个,后面我完成对于这种数据结构的介绍后再替换链接 红黑树

我们详细来看这个方法,首先如果table为空,会调用resize方法创建table(稍后我介绍这个resize方法),然后,像1.7一样,判断通过hash计算的下标对应的table的位置是不是有节点,没有的话直接创建,如果有的话,看这个节点是不是和带插入的key相同,如果相同,直接替换value,然后判断是以什么方法插入,可能是以红黑树插入节点的方法,也可能是链表。如果是链表,还要判断一下是不是到了上限,如果到了阈值,直接变成红黑树。最后这个if是为了如果是发生了替换,直接返回oldvalue。

简单介绍完了这个put方法,我们着重介绍里面的两个比较关键的方法,扩容方法resize以及将链表变红黑树的方法treeifyBin方法。

resize

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    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;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    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;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

这个resize方法可能会在table为空或者现在容量要到达阈值时,我们现在的table还没有初始化,所以这个方法的oldTab=null,在这种状态下,我们可以看到走的是这条分支

else {               // zero initial threshold signifies using defaults
    newCap = DEFAULT_INITIAL_CAPACITY;
    newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}

这个逻辑我们其实是似曾相识的,这和1.7是相似的,其实包括后面的方法也是相同的,就是重新创建一个更大的Table,把原来的复制到这个table上。这里我想特别的提一下,如果用户自己设定了capacity,其实HashMap也会找到一个大于等于这个cap且为2的倍数的数量当成这个HashMap的容量,但是方法变了一下,实现方法如下:

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;
}

我们以cap=15为例做了个例子,如图所示

HashMap漫谈(2)
HashMap漫谈(2)

回到这个方法,总体来说,这个方法的逻辑如下:

1、计算新桶数组的容量 newCap 和新阈值 newThr
2、根据计算出的 newCap 创建新的桶数组,桶数组 table 也是在这里进行初始化的
3、将键值对节点重新映射到新的桶数组里。如果节点是 TreeNode 类型,则需要拆分红黑树。如果是普通节点,则节点按原顺序进行分组。

我们简单看一下这个拆解链表的过程,也就是这一段代码,对于红黑树的操作,我还是打算单独拉出一篇文章单独讲,所以这里先忽略,读完这篇文章后,只需要知道JDK1.8中有这么个操作就好

else { // preserve order
    Node<K,V> loHead = null, loTail = null;
    Node<K,V> hiHead = null, hiTail = null;
    Node<K,V> next;
    do {
        next = e.next;
        if ((e.hash & oldCap) == 0) {
            if (loTail == null)
                loHead = e;
            else
                loTail.next = e;
            loTail = e;
        }
        else {
            if (hiTail == null)
                hiHead = e;
            else
                hiTail.next = e;
            hiTail = e;
        }
    } while ((e = next) != null);
    if (loTail != null) {
        loTail.next = null;
        newTab[j] = loHead;
    }
    if (hiTail != null) {
        hiTail.next = null;
        newTab[j + oldCap] = hiHead;
    }
}

这里我们假设cap从8扩大到16,那么oldCap就应该是8,newCap就是16,假设有4个hash,35,27,19,43,遍历链表,分别计算hash & oldCap

那么通过计算可知:35 & 8 = 0;19 & 8 = 0;27 & 8 != 0;43 & 8 != 0

这样我们看lo应该是等于0的不等于0的是loIndex + oldCap的位置,最后可以转变为如下的图

HashMap漫谈(2)

至此我们就看完了resize的过程。

下面我们看一下treeifyBin方法的实现

treeifyBin

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);
    }
}

树化有两个条件会触发,分别为:

1、链表长度大于等于 TREEIFY_THRESHOLD
2、桶数组容量大于等于 MIN_TREEIFY_CAPACITY

这里我们看到最后从Node变为了TreeNode,通过调用replacementTreeNode方法,我们首先看一下TreeNode的结构定义


谢谢你请我吃糖果

原文 

https://bryantchang.github.io/2018/08/15/java-hashmap2/

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » HashMap漫谈(2)

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址