【集合系列】- 深入浅出分析HashMap

一、摘要

在集合系列的第一章，咱们了解到，map的实现类有hashmap、linkedhashmap、treemap、identityhashmap、weakhashmap、hashtable、properties等等。

关于hashmap，一直都是一个非常热门的话题，只要你出去面试，我保证一定少不了它！

本文主要结合jdk1.7和jdk1.8的区别，就hashmap的数据结构和实现功能，进行深入探讨，废话也不多说了，直奔主题！

二、简介

在程序编程的时候，hashmap是一个使用非常频繁的容器类，它允许键值都放入null元素。除该类方法未实现同步外，其余跟hashtable大致相同，但跟treemap不同，该容器不保证元素顺序，根据需要该容器可能会对元素重新哈希，元素的顺序也会被重新打散，因此不同时间迭代同一个hashmap的顺序可能会不同。

hashmap容器，实质还是一个哈希数组结构，但是在元素插入的时候，存在发生hash冲突的可能性；

对于发生hash冲突的情况，冲突有两种实现方式，一种开放地址方式（当发生hash冲突时，就继续以此继续寻找，直到找到没有冲突的hash值），另一种是拉链方式（将冲突的元素放入链表）。java hashmap采用的就是第二种方式，拉链法。

在jdk1.7中，hashmap主要是由数组+链表组成，当发生hash冲突的时候，就将冲突的元素放入链表中。

从jdk1.8开始，hashmap主要是由数组+链表+红黑树实现的，相比jdk1.7而言，多了一个红黑树实现。当链表长度超过8的时候，就将链表变成红黑树，如图所示。

关于红黑树的实现，因为篇幅太长，在《集合系列》文章中红黑树设计，也有所介绍，这里就不在详细介绍了。

三、源码解析

直接打开hashmap的源码分析，可以看到，主要有5个关键参数：

• threshold：表示容器所能容纳的key-value对极限。
• loadfactor：负载因子。
• modcount：记录修改次数。
• size：表示实际存在的键值对数量。
• table：一个哈希桶数组，键值对就存放在里面。

public class hashmap<k,v> extends abstractmap<k,v>
    implements map<k,v>, cloneable, serializable {
    
    //所能容纳的key-value对极限
    int threshold;
    
    //负载因子
    final float loadfactor;
    
    //记录修改次数
    int modcount;
    
    //实际存在的键值对数量
    int size;
    
    //哈希桶数组
    transient node<k,v>[] table;
}

接着来看看node这个类，node是hashmap的一个内部类，实现了map.entry接口，本质是就是一个映射(键值对)

static class node<k,v> implements map.entry<k,v> {
        final int hash;//hash值
        final k key;//k键
        v value;//value值
        node<k,v> next;//链表中下一个元素
}

在hashmap的数据结构中，有两个参数可以影响hashmap的性能：初始容量（inital capacity）和负载因子（load factor）。

初始容量（inital capacity）是指table的初始长度length（默认值是16）；
负载因子（load factor）用指自动扩容的临界值（默认值是0.75）；

threshold是hashmap所能容纳的最大数据量的node(键值对)个数，计算公式threshold = capacity * load factor。当entry的数量超过capacity*load_factor时，容器将自动扩容并重新哈希，扩容后的hashmap容量是之前容量的两倍，所以数组的长度总是2的n次方。

初始容量和负载因子也可以修改，具体实现方式，可以在对象初始化的时候，指定参数，比如：

map map = new hashmap(int initialcapacity, float loadfactor);

但是，默认的负载因子0.75是对空间和时间效率的一个平衡选择，建议大家不要修改，除非在时间和空间比较特殊的情况下，如果内存空间很多而又对时间效率要求很高，可以降低负载因子load factor的值；相反，如果内存空间紧张而对时间效率要求不高，可以增加负载因子loadfactor的值，这个值可以大于1。 同时，对于插入元素较多的场景，可以将初始容量设大，减少重新哈希的次数。

hashmap的内部功能实现有很多，本文主要从以下几点，进行逐步分析。

• 通过k获取数组下标；
• put方法的详细执行；
• resize扩容过程；
• get方法获取参数值；
• remove删除元素；

3.1、通过k获取数组下标

不管增加、删除还是查找键值对，定位到数组的位置都是很关键的第一步，打开hashmap的任意一个增加、删除、查找方法，从源码可以看出，通过key获取数组下标，主要做了3步操作，其中length指的是容器数组的大小。

源码部分：

/**获取hash值方法*/
static final int hash(object key) {
     int h;
     // h = key.hashcode() 为第一步 取hashcode值（jdk1.7）
     // h ^ (h >>> 16)  为第二步 高位参与运算（jdk1.7）
     return (key == null) ? 0 : (h = key.hashcode()) ^ (h >>> 16);//jdk1.8
}
/**获取数组下标方法*/
static int indexfor(int h, int length) {
    //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
     return h & (length-1);  //第三步 取模运算
}

3.2、put方法的详细执行

put(k key, v value)方法是将指定的key, value对添加到map里。该方法首先会对map做一次查找，看是否包含该k，如果已经包含则直接返回；如果没有找到，则将元素插入容器。具体插入过程如下：

具体执行步骤

• 1、判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容；
• 2、根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加；
• 3、当table[i]不为空，判断table[i]的首个元素是否和传入的key一样，如果相同直接覆盖value；
• 4、判断table[i] 是否为treenode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对；
• 5、遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；
• 6、插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容操作；

put方法源码部分

/**
 * put方法
 */
public v put(k key, v value) {
        return putval(hash(key), key, value, false, true);
}

插入元素方法

/**
 * 插入元素方法
 */
 final v putval(int hash, k key, v value, boolean onlyifabsent,
                   boolean evict) {
        node<k,v>[] tab; node<k,v> p; int n, i;
        //1、判断数组table是否为空或为null
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //2、判断数组下标table[i]==null
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newnode(hash, key, value, null);
        else {
            node<k,v> e; k k;
            //3、判断table[i]的首个元素是否和传入的key一样
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //4、判断table[i] 是否为treenode
            else if (p instanceof treenode)
                e = ((treenode<k,v>)p).puttreeval(this, tab, hash, key, value);
            else {
                //5、遍历table[i]，判断链表长度是否大于8
                for (int bincount = 0; ; ++bincount) {
                    if ((e = p.next) == null) {
                        p.next = newnode(hash, key, value, null);
                        //长度大于8，转红黑树结构
                        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;
                }
            }
            //传入的k元素已经存在，直接覆盖value
            if (e != null) { // existing mapping for key
                v oldvalue = e.value;
                if (!onlyifabsent || oldvalue == null)
                    e.value = value;
                afternodeaccess(e);
                return oldvalue;
            }
        }
        ++modcount;
        //6、判断size是否超出最大容量
        if (++size > threshold)
            resize();
        afternodeinsertion(evict);
        return null;
}

其中，与jdk1.7有区别的地方，第4步新增了红黑树插入方法，源码部分：

/**
   * 红黑树的插入操作
   */
final treenode<k,v> puttreeval(hashmap<k,v> map, node<k,v>[] tab,
                                       int h, k k, v v) {
            class<?> kc = null;
            boolean searched = false;
            treenode<k,v> root = (parent != null) ? root() : this;
            for (treenode<k,v> p = root;;) {
                //dir:遍历的方向， ph:p节点的hash值
                int dir, ph; k pk;
                //红黑树是根据hash值来判断大小
                // -1:左孩子方向 1:右孩子方向
                if ((ph = p.hash) > h)
                    dir = -1;
                else if (ph < h)
                    dir = 1;
                //如果key存在的话就直接返回当前节点
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
                    return p;
                //如果当前插入的类型和正在比较的节点的key是comparable的话，就直接通过此接口比较
                else if ((kc == null &&
                          (kc = comparableclassfor(k)) == null) ||
                         (dir = comparecomparables(kc, k, pk)) == 0) {
                    if (!searched) {
                        treenode<k,v> q, ch;
                        searched = true;
                        //尝试在p的左子树或者右子树中找到了目标元素
                        if (((ch = p.left) != null &&
                             (q = ch.find(h, k, kc)) != null) ||
                            ((ch = p.right) != null &&
                             (q = ch.find(h, k, kc)) != null))
                            return q;
                    }
                    //获取遍历的方向
                    dir = tiebreakorder(k, pk);
                }
                //上面的所有if-else判断都是在判断下一次进行遍历的方向，即dir
                treenode<k,v> xp = p;
                //当下面的if判断进去之后就代表找到了目标操作元素,即xp
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    node<k,v> xpn = xp.next;
                    //插入新的元素
                    treenode<k,v> x = map.newtreenode(h, k, v, xpn);
                    if (dir <= 0)
                        xp.left = x;
                    else
                        xp.right = x;
                    //因为treenode今后可能退化成链表，在这里需要维护链表的next属性
                    xp.next = x;
                    //完成节点插入操作
                    x.parent = x.prev = xp;
                    if (xpn != null)
                        ((treenode<k,v>)xpn).prev = x;
                    //插入操作完成之后就要进行一定的调整操作了
                    moveroottofront(tab, balanceinsertion(root, x));
                    return null;
                }
       }
}

3.3、resize扩容过程

在说jdk1.8的hashmap动态扩容之前，我们先来了解一下jdk1.7的hashmap扩容实现，因为jdk1.8代码实现比java1.7复杂了不止一倍，主要是java1.8引入了红黑树设计，但是实现思想大同小异！

3.3.1、jdk1.7的扩容实现

源码部分

/**
  * jdk1.7扩容方法
  * 传入新的容量
  */
void resize(int newcapacity) {
    //引用扩容前的entry数组
    entry[] oldtable = table;
    int oldcapacity = oldtable.length;
    //扩容前的数组大小如果已经达到最大(2^30)了
    if (oldcapacity == maximum_capacity) {
        //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
        threshold = integer.max_value;
        return;
    }
    //初始化一个新的entry数组
    entry[] newtable = new entry[newcapacity];
    //将数据转移到新的entry数组里，这里包含最重要的重新定位
    transfer(newtable);
    //hashmap的table属性引用新的entry数组
    table = newtable;
    threshold = (int) (newcapacity * loadfactor);//修改阈值
}

transfer复制数组方法，源码部分：

//遍历每个元素，按新的容量进行rehash，放到新的数组上
void transfer(entry[] newtable) {
    //src引用了旧的entry数组
    entry[] src = table;
    int newcapacity = newtable.length;
    for (int j = 0; j < src.length; j++) {
        //遍历旧的entry数组
        entry<k, v> e = src[j];
        //取得旧entry数组的每个元素
        if (e != null) {
            //释放旧entry数组的对象引用（for循环后，旧的entry数组不再引用任何对象）
            src[j] = null;
            do {
                entry<k, v> next = e.next;
                //重新计算每个元素在数组中的位置
                //实现逻辑，也是上文那个取模运算方法
                int i = indexfor(e.hash, newcapacity);
                //标记数组
                e.next = newtable[i];
                //将元素放在数组上
                newtable[i] = e;
                //访问下一个entry链上的元素，循环遍历
                e = next;
            } while (e != null);
        }  
    }  
}

jdk1.7扩容总结：newtable[i]的引用赋给了e.next，也就是使用了单链表的头插入方式，同一位置上新元素总会被放在链表的头部位置；这样先放在一个索引上的元素终会被放到entry链的尾部(如果发生了hash冲突的话），这一点和jdk1.8有区别。在旧数组中同一条entry链上的元素，通过重新计算索引位置后，有可能被放到了新数组的不同位置上。

3.3.2、jdk1.8的扩容实现

源码如下

final node<k,v>[] resize() {
        //引用扩容前的node数组
        node<k,v>[] oldtab = table;
        //旧的容量
        int oldcap = (oldtab == null) ? 0 : oldtab.length;
        //旧的阈值
        int oldthr = threshold;
        //新的容量、阈值初始化为0
        int newcap, newthr = 0;
        if (oldcap > 0) {
            //如果旧容量已经超过最大容量，让阈值也等于最大容量，以后不再扩容
                threshold = integer.max_value;
            if (oldcap >= maximum_capacity) {
                threshold = integer.max_value;
                return oldtab;
            }
            // 没超过最大值，就扩充为原来的2倍
            else if ((newcap = oldcap << 1) < maximum_capacity &&
                     oldcap >= default_initial_capacity)
                //如果旧容量翻倍没有超过最大值，且旧容量不小于初始化容量16，则翻倍
                newthr = oldthr << 1; // double threshold
        }
        else if (oldthr > 0) // initial capacity was placed in threshold
            //初始化容量设置为阈值
            newcap = oldthr;
        else {               // zero initial threshold signifies using defaults
            //0的时候使用默认值初始化
            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;
                    //如果e没有next节点，证明这个节点上没有hash冲突，则直接把e的引用给到新的数组位置上
                    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 {
                        // 链表优化重hash的代码块
                        node<k,v> lohead = null, lotail = null;
                        node<k,v> hihead = null, hitail = null;
                        node<k,v> next;
                        //从这条链表上第一个元素开始轮询，如果当前元素新增的bit是0，则放在当前这条链表上，如果是1，则放在"j+oldcap"这个位置上，生成“低位”和“高位”两个链表
                        do {
                            next = e.next;
                            if ((e.hash & oldcap) == 0) {
                                if (lotail == null)
                                    lohead = e;
                                else
                                    //元素是不断的加到尾部的，不会像1.7里面一样会倒序
                                    lotail.next = e;
                                //新增的元素永远是尾元素
                                lotail = e;
                            }
                            else {
                                //高位的链表与低位的链表处理逻辑一样，不断的把元素加到链表尾部
                                if (hitail == null)
                                    hihead = e;
                                else
                                    hitail.next = e;
                                hitail = e;
                            }
                        } while ((e = next) != null);
                        //低位链表放到j这个索引的位置上
                        if (lotail != null) {
                            lotail.next = null;
                            newtab[j] = lohead;
                        }
                        //高位链表放到(j+oldcap)这个索引的位置上
                        if (hitail != null) {
                            hitail.next = null;
                            newtab[j + oldcap] = hihead;
                        }
                    }
                }
            }
        }
        return newtab;
}

1.7与1.8处理逻辑大同小异，区别主要还是在树节点的分裂((treenode<k,v>)e).split()这个方法上

/**
 * 红黑树分裂方法
 */
final void split(hashmap<k,v> map, node<k,v>[] tab, int index, int bit) {
            //当前这个节点的引用，即这个索引上的树的根节点
            treenode<k,v> b = this;
            // relink into lo and hi lists, preserving order
            treenode<k,v> lohead = null, lotail = null;
            treenode<k,v> hihead = null, hitail = null;
            //高位低位的初始树节点个数都设成0
            int lc = 0, hc = 0;
            for (treenode<k,v> e = b, next; e != null; e = next) {
                next = (treenode<k,v>)e.next;
                e.next = null;
                //bit=oldcap,这里判断新bit位是0还是1，如果是0就放在低位树上，如果是1就放在高位树上，这里先是一个双向链表
                if ((e.hash & bit) == 0) {
                    if ((e.prev = lotail) == null)
                        lohead = e;
                    else
                        lotail.next = e;
                    lotail = e;
                    ++lc;
                }
                else {
                    if ((e.prev = hitail) == null)
                        hihead = e;
                    else
                        hitail.next = e;
                    hitail = e;
                    ++hc;
                }
            }

            if (lohead != null) {
                if (lc <= untreeify_threshold)
                    //！！！如果低位的链表长度小于阈值6，则把树变成链表，并放到新数组中j索引位置
                    tab[index] = lohead.untreeify(map);
                else {
                    tab[index] = lohead;
                    //高位不为空，进行红黑树转换
                    if (hihead != null) // (else is already treeified)
                        lohead.treeify(tab);
                }
            }
            if (hihead != null) {
                if (hc <= untreeify_threshold)
                    tab[index + bit] = hihead.untreeify(map);
                else {
                    tab[index + bit] = hihead;
                    if (lohead != null)
                        hihead.treeify(tab);
                }
            }
}

untreeify方法，将树转变为单向链表

/**
 * 将树转变为单向链表
 */
final node<k,v> untreeify(hashmap<k,v> map) {
            node<k,v> hd = null, tl = null;
            for (node<k,v> q = this; q != null; q = q.next) {
                node<k,v> p = map.replacementnode(q, null);
                if (tl == null)
                    hd = p;
                else
                    tl.next = p;
                tl = p;
            }
            return hd;
}

treeify方法，将链表转换为红黑树，会根据红黑树特性进行颜色转换、左旋、右旋等

/**
 * 链表转换为红黑树，会根据红黑树特性进行颜色转换、左旋、右旋等
 */
final void treeify(node<k,v>[] tab) {
            treenode<k,v> root = null;
            for (treenode<k,v> x = this, next; x != null; x = next) {
                next = (treenode<k,v>)x.next;
                x.left = x.right = null;
                if (root == null) {
                    x.parent = null;
                    x.red = false;
                    root = x;
                }
                else {
                    k k = x.key;
                    int h = x.hash;
                    class<?> kc = null;
                    for (treenode<k,v> p = root;;) {
                        int dir, ph;
                        k pk = p.key;
                        if ((ph = p.hash) > h)
                            dir = -1;
                        else if (ph < h)
                            dir = 1;
                        else if ((kc == null &&
                                  (kc = comparableclassfor(k)) == null) ||
                                 (dir = comparecomparables(kc, k, pk)) == 0)
                            dir = tiebreakorder(k, pk);

                        treenode<k,v> xp = p;
                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
                            x.parent = xp;
                            if (dir <= 0)
                                xp.left = x;
                            else
                                xp.right = x;
                            //进行左旋、右旋调整
                            root = balanceinsertion(root, x);
                            break;
                        }
                    }
                }
            }
            moveroottofront(tab, root);
}

jdk1.8在进行重新扩容之后，会重新计算hash值，因为n变为2倍，假设初始 tablesize = 4 要扩容到 8 来说就是 0100 到 1000 的变化（左移一位就是 2 倍），在扩容中只用判断原来的 hash 值与左移动的一位（newtable 的值）按位与操作是 0 或 1 就行，0 的话索引就不变，1 的话索引变成原索引 + oldcap；

其实现如下流程图所示：

可以看见，因为 hash 值本来就是随机性的，所以 hash 按位与上 newtable 得到的 0（扩容前的索引位置）和 1（扩容前索引位置加上扩容前数组长度的数值索引处）就是随机的，所以扩容的过程就能把之前哈希冲突的元素再随机的分布到不同的索引去，这算是 jdk1.8 的一个优化点。

此外，jdk1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出，jdk1.8不会倒置。

同时，由于 jdk1.7 中发生哈希冲突时仅仅采用了链表结构存储冲突元素，所以扩容时仅仅是重新计算其存储位置而已。而 jdk1.8 中为了性能在同一索引处发生哈希冲突到一定程度时，链表结构会转换为红黑数结构存储冲突元素，故在扩容时如果当前索引中元素结构是红黑树且元素个数小于链表还原阈值时就会把树形结构缩小或直接还原为链表结构（其实现就是上面代码片段中的 split() 方法）。

3.4、get方法获取参数值

get(object key)方法根据指定的key值返回对应的value，getnode(hash(key), key))得到相应的node对象e，然后返回e.value。因此getnode()是算法的核心。

get方法源码部分：

/**
  * jdk1.8 get方法
  * 通过key获取参数值
  */
public v get(object key) {
        node<k,v> e;
        return (e = getnode(hash(key), key)) == null ? null : e.value;
}

通过hash值和key获取节点node方法，源码部分：

final node<k,v> getnode(int hash, object key) {
        node<k,v>[] tab; node<k,v> first, e; int n; k k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //1、判断第一个元素是否与key匹配
            if (first.hash == hash &&
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                //2、判断链表是否红黑树结构
                if (first instanceof treenode)
                    return ((treenode<k,v>)first).gettreenode(hash, key);
                //3、如果不是红黑树结构，直接循环判断
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
}

在红黑树中找到指定k的treenode，源码部分：

/**
  * 这里面情况分很多中，主要是因为考虑了hash相同但是key值不同的情况，查找的最核心还是落在key值上
  */
final treenode<k,v> find(int h, object k, class<?> kc) {
            treenode<k,v> p = this;
            do {
                int ph, dir; k pk;
                treenode<k,v> pl = p.left, pr = p.right, q;
                //判断要查询元素的hash是否在树的左边
                if ((ph = p.hash) > h)
                    p = pl;
                //判断要查询元素的hash是否在树的右边
                else if (ph < h)
                    p = pr;
                //查询元素的hash与当前树节点hash相同情况
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
                    return p;
                //上面的三步都是正常的在二叉查找树中寻找对象的方法
                //如果hash相等，但是内容却不相等
                else if (pl == null)
                    p = pr;
                else if (pr == null)
                    p = pl;
                 //如果可以根据compareto进行比较的话就根据compareto进行比较
                else if ((kc != null ||
                          (kc = comparableclassfor(k)) != null) &&
                         (dir = comparecomparables(kc, k, pk)) != 0)
                    p = (dir < 0) ? pl : pr;
                //根据compareto的结果在右孩子上继续查询
                else if ((q = pr.find(h, k, kc)) != null)
                    return q;
                //根据compareto的结果在左孩子上继续查询
                else
                    p = pl;
            } while (p != null);
            return null;
}

get方法，首先通过hash()函数得到对应数组下标，然后依次判断。

• 1、判断第一个元素与key是否匹配，如果匹配就返回参数值；
• 2、判断链表是否红黑树，如果是红黑树，就进入红黑树方法获取参数值；
• 3、如果不是红黑树结构，直接循环判断，直到获取参数为止；

3.5、remove删除元素

remove(object key)的作用是删除key值对应的node，该方法的具体逻辑是在removenode(hash(key), key, null, false, true)里实现的。

remove方法，源码部分：

/**
  * jdk1.8 remove方法
  * 通过key移除对象
  */
public v remove(object key) {
        node<k,v> e;
        return (e = removenode(hash(key), key, null, false, true)) == null ?
            null : e.value;
}

通过key移除node节点方法，源码部分：

/**
  * 通过key移除node节点
  */
final node<k,v> removenode(int hash, object key, object value,
                               boolean matchvalue, boolean movable) {
        node<k,v>[] tab; node<k,v> p; int n, index;
        //1、判断要删除的元素，是否存在
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            node<k,v> node = null, e; k k; v v;
            //2、判断第一个元素是不是我们要找的元素
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = p.next) != null) {
                //3、判断当前冲突链表是否红黑树结构
                if (p instanceof treenode)
                    node = ((treenode<k,v>)p).gettreenode(hash, key);
                else {
                    //4、循环在链表中找到需要删除的元素
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            //上面的逻辑，基本都是为了找到要删除元素的节点
            if (node != null && (!matchvalue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                //5、如果当前冲突链表结构是红黑树，执行红黑树删除方法
                if (node instanceof treenode)
                    ((treenode<k,v>)node).removetreenode(this, tab, movable);
                else if (node == p)
                    tab[index] = node.next;
                else
                    p.next = node.next;
                ++modcount;
                --size;
                afternoderemoval(node);
                return node;
            }
        }
        return null;
}

removetreenode移除红黑树节点方法，源码部分：

final void removetreenode(hashmap<k,v> map, node<k,v>[] tab,
                                  boolean movable) {
            int n;
            if (tab == null || (n = tab.length) == 0)
                return;
            int index = (n - 1) & hash;
            treenode<k,v> first = (treenode<k,v>)tab[index], root = first, rl;
            treenode<k,v> succ = (treenode<k,v>)next, pred = prev;
            if (pred == null)
                tab[index] = first = succ;
            else
                pred.next = succ;
            if (succ != null)
                succ.prev = pred;
            if (first == null)
                return;
            if (root.parent != null)
                root = root.root();
            if (root == null || root.right == null ||
                (rl = root.left) == null || rl.left == null) {
                tab[index] = first.untreeify(map);  // too small
                return;
            }
            treenode<k,v> p = this, pl = left, pr = right, replacement;
            if (pl != null && pr != null) {
                treenode<k,v> s = pr, sl;
                while ((sl = s.left) != null) // find successor
                    s = sl;
                boolean c = s.red; s.red = p.red; p.red = c; // swap colors
                treenode<k,v> sr = s.right;
                treenode<k,v> pp = p.parent;
                if (s == pr) { // p was s's direct parent
                    p.parent = s;
                    s.right = p;
                }
                else {
                    treenode<k,v> sp = s.parent;
                    if ((p.parent = sp) != null) {
                        if (s == sp.left)
                            sp.left = p;
                        else
                            sp.right = p;
                    }
                    if ((s.right = pr) != null)
                        pr.parent = s;
                }
                p.left = null;
                if ((p.right = sr) != null)
                    sr.parent = p;
                if ((s.left = pl) != null)
                    pl.parent = s;
                if ((s.parent = pp) == null)
                    root = s;
                else if (p == pp.left)
                    pp.left = s;
                else
                    pp.right = s;
                if (sr != null)
                    replacement = sr;
                else
                    replacement = p;
            }
            else if (pl != null)
                replacement = pl;
            else if (pr != null)
                replacement = pr;
            else
                replacement = p;
            if (replacement != p) {
                treenode<k,v> pp = replacement.parent = p.parent;
                if (pp == null)
                    root = replacement;
                else if (p == pp.left)
                    pp.left = replacement;
                else
                    pp.right = replacement;
                p.left = p.right = p.parent = null;
            }
            //判断是否需要进行红黑树结构调整
            treenode<k,v> r = p.red ? root : balancedeletion(root, replacement);

            if (replacement == p) {  // detach
                treenode<k,v> pp = p.parent;
                p.parent = null;
                if (pp != null) {
                    if (p == pp.left)
                        pp.left = null;
                    else if (p == pp.right)
                        pp.right = null;
                }
            }
            if (movable)
                moveroottofront(tab, r);
}

jdk1.8的删除逻辑实现比较复杂，相比jdk1.7而言，多了红黑树节点删除和调整：

• 1、默认判断链表第一个元素是否是要删除的元素；
• 2、如果第一个不是，就继续判断当前冲突链表是否是红黑树，如果是，就进入红黑树里面去找；
• 3、如果当前冲突链表不是红黑树，就直接在链表中循环判断，直到找到为止；
• 4、将找到的节点，删除掉，如果是红黑树结构，会进行颜色转换、左旋、右旋调整，直到满足红黑树特性为止；

四、总结

1、如果key是一个对象，记得在对象实体类里面，要重写equals和hashcode方法，不然在查询的时候，无法通过对象key来获取参数值！
2、相比jdk1.7，jdk1.8引入红黑树设计，当链表长度大于8的时候，链表会转化为红黑树结构，发生冲突的链表如果很长，红黑树的实现很大程度优化了hashmap的性能，使查询效率比jdk1.7要快一倍！
3、对于大数组的情况，可以提前给map初始化一个容量，避免在插入的时候，频繁的扩容，因为扩容本身就比较消耗性能！

五、参考

1、jdk1.7&jdk1.8 源码
2、美团技术团队 - java 8系列之重新认识hashmap
3、简书 - jdk1.8红黑树实现分析-此鱼不得水
4、简书 - jjdk 1.8 中 hashmap 扩容
5、java hashmap 基础面试常见问题

作者：炸鸡可乐
出处：