hashmap删除指定key_HashMap底层实现机制及源码解析

HashMap简介

本篇文章是自己在学习HashMap的过程中自己的总结，并不一定完全正确，主要是记录自己的学习过程。

• HashMap是一种映射关系，是hash值与实际存储对象之间的映射，也就是键值对的关系，通过关键字key找到实际存储的值value，是一种数据结构
• 什么是hash：本质上是把任意长度的输入，通过算法变换成固定长度的输出
• 在学习Java的过程中，最常见的两种数据结构是数组和链表，那么数组和链表各有什么优缺点？数组：数组在物理空间中是连续的，数组对象直接指向数组首地址，在查找的时候效率高，但是由于空间是连续的，所以当物理空间的碎片比较多时，当我们想存入比较大的数组的时候，即使可能空间足够，但由于这些空间不是连续的，就无法存入链表：链表在物理空间中不是连续的，在存放数据的同时还需要存放下一个链节点的地址，相比于数组，不受空间是否是碎片化的影响，只要有空间，就能存储数据。但是查找效率没有数组高，插入和删除的效率比数组高
• HashMap：HashMap将数组和链表结合起来，既能够提高查找效率，删除和插入的效率也提高了。

内部组成

• HashMap的存储形式：键值对的存储形式
• 数据结构：数组+链表+红黑树
• 内部成员：默认初始容量DEFAULT_INITIAL_CAPACITY：16默认负载因子DEFAULT_LOAD_FACTOR：默认为0.75，表示整体上table被占用程度TREEIFY_THRESHOLD：8，当数组中有某个索引位置上的链表长度大于该常量时，就将该链表转换成红黑树UNTREEIFY_THRESHOLD：6，当链表的长度小于该常量时，就将红黑树转换成链表阈值threshold：当数组中键值对个数大于阈值时进行扩展，计算方式是hashmap长度*负载因子Node[] table：数组

构造方法

• HashMap map = new HashMap();无参的构造方法，只初始化了负载因子，默认为0.75
• HashMap map = new HashMap(int initialCapacity);参数为map的初始容量，负载因子为默认值0.75，底层实际上是调用了HashMap(int initialCapacity, float loadFactor)
• HashMap map = new HashMap(int initialCapacity, float loadFactor)指定初始的容量以及负载因子
• HashMap map = new HashMap(Map m);初始化负载因子，默认为0.75调用putMapEntries方法，将集合m全部都装进新的map集合里方法的执行步骤如下：获取m的实际判读，判断是否大于0，只有当大于0时才才执行判断map的table数组是否为空，如果为空计算map的阈值如果table数组不为空，判断s的实际长度是否大于map的阈值，如果大于对map集合进行扩容当map的长度确定下来之后，遍历m集合，把键值对取出来存入map集合当中

增删查方法源码解析

• hash值计算过程：

static final int hash(Object key) {        int h;        //判断key的值是否为空            // 如果为空则返回0            // 如果不为空则调用key的hashCode方法计算出hash值            //     并让hash值的高16位与低16位进行异或操作，得出最后的hash值        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);    }

• put方法

put方法大致的流程可以分为以下几点：

* 1)计算hash值，根据hash值得出索引值，采用的是当前table长度-1 & hash值相与得出索引值(hash值是通过上面的hash方法计算得出，而不是调用hashCode方法)    举个例子：存入两个key的hash值分别为14和35，而当前table的长度为默认容量16(2^n)    那么第一个key对应的索引值为：0000 1110 & 0000 1111，得出索引值为14    第二个key对应的索引值为：0010 0011 & 0000 1111，得出索引值为3    这样做能确保每个不论hash值有多大，都能够存入数组，截取的是hash值的二进制数的后n位* 2)根据hash找到对应的索引值，有三种情况：    * 当前位置为空，直接存入    * 当前位置不为空，且是链表，插入到链表的尾部    * 当前位置为空，且是红黑树，插入到红黑树当中* 3)判断当前table的实际长度size是否超出阈值threshold，如果超出则进行扩容

以下是对源码的解读：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {        HashMap.Node[] tab; HashMap.Node p; int n, i;        //2)判断 table数组是否为空 || table数组的长度是否0，也就是是否是第一次存放        if ((tab = table) == null || (n = tab.length) == 0)            //其中一个条件满足，给table扩容            n = (tab = resize()).length;        //3)计算 (数组长度 - 1 & hash值)，得出索引值，获取对应索引的值，判断是否为空        if ((p = tab[i = (n - 1) & hash]) == null)            //如果为空，在该索引位置创建一个新的节点，并放入            tab[i] = newNode(hash, key, value, null);        //4)如果不为空，证明该索引位置已经有值了        else {            HashMap.Node e; K k;            //判断是否是同一个key            if (p.hash == hash &&                    ((k = p.key) == key || (key != null && key.equals(k))))                //如果是同一个就赋给e(赋给e是为了接下来是否要覆盖该位置的值做准备)                e = p;            //如果不是同一个key，判断是否是树节点，如果是树节点，把节点插入到红黑树里面            else if (p instanceof HashMap.TreeNode)                e = ((HashMap.TreeNode)p).putTreeVal(this, tab, hash, key, value);            //如果既不是同一个key，也不是树节点，那只可能是链表            else {                //循环链表，判断每个节点的key是否与要插入的key相同，如果相同则覆盖掉。                //binCount记录该链表的节点位置                for (int binCount = 0; ; ++binCount) {                    //判断当前位置是否是尾结点                    if ((e = p.next) == null) {                        //如果是尾节点，则在为节点的下一个节点插入新的节点(尾插法)                        p.next = newNode(hash, key, value, null);                        //判断当前链表的节点树是否大于(TREEIFY_THRESHOLD - 1)                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st                            //如果大于则将链表转换成红黑树                            treeifyBin(tab, hash);                        //跳出循环                        break;                    }                    //判断当前位置和我们要存入的key是否相同，如果相同则跳出循环                    if (e.hash == hash &&                            ((k = e.key) == key || (key != null && key.equals(k))))                        break;                    //如果以上两个判断都不满足，继续遍历下一个节点                    p = e;                }            }            //判断e是否为空            if (e != null) { // existing mapping for key                //不为空，取出e的value值                V oldValue = e.value;                //onlyIfAbsent如果为false，则表示如果出现的key相同，则覆盖掉原来的值，反之就不覆盖                    //可以参考HashMap的另一个方法，putIfAbsent的源码，里面的onlyIfAbsent就设为true                //还有一种情况：本来存放的value是null,那么不管onlyIfAbsent是true还是false，一定会被覆盖掉                if (!onlyIfAbsent || oldValue == null)                    //覆盖掉原本的value值                    e.value = value;                afterNodeAccess(e);                return oldValue;            }        }        //记录修改次数        ++modCount;        //判断存入之后的size是否大于阈值        if (++size > threshold)            //如果大于则扩容，扩容的方法可以往下翻            resize();        afterNodeInsertion(evict);        return null;    }

• remove(key)方法

remove的方法流程大致如下：

• 计算hash值，根据hash值计算出索引位置
• 找到要删除的索引位置的值
• 该值有如下三种情况当前节点链表上的几点红黑树上的几点
• 根据找到的节点再做判断如果是红黑树，那么将该节点从红黑树上删掉如果是链表，进行断链操作如果是当前节点，该索引位置指向当前节点的下一节点

具体源码如下：

// 1)判断key是否为空，并计算出hash值    final HashMap.Node removeNode(int hash, Object key, Object value,                                       boolean matchValue, boolean movable) {        HashMap.Node[] tab; HashMap.Node p; int n, index;        //1)判断内部的table数组是否为空 && table数组长度是否大于0        // && (当前table的长度-1)与 hash值 相与，取出该索引位置的值，判断是否为空        if ((tab = table) != null && (n = tab.length) > 0 &&                (p = tab[index = (n - 1) & hash]) != null) {            HashMap.Node node = null, e; K k; V v;            //2)如果当前索引位置的值p与要删除的key是相同的话            //  把p赋给节点node(赋给节点node是为了删除完之后还要返回被删除节点的值)            if (p.hash == hash &&                    ((k = p.key) == key || (key != null && key.equals(k))))                node = p;            //3)如果不相同，判断当前节点的下一个节点是否为空            //如果不为空，可能要删除的点是链表中的某一个节点或者是树节点(红黑树)            else if ((e = p.next) != null) {                //判断是否是树节点                if (p instanceof HashMap.TreeNode)                    //如果是树节点，根据当前节点找到根节点，并根据根节点往下找直到找到要删除的节点                    node = ((HashMap.TreeNode)p).getTreeNode(hash, key);                //如果是链表，则遍历链表，直到找到要删除的节点                else {                    do {                        if (e.hash == hash &&                                ((k = e.key) == key ||                                        (key != null && key.equals(k)))) {                            node = e;                            break;                        }                        p = e;                    } while ((e = e.next) != null);                }            }            //如果找到的节点node不等于空，判断该节点的结构            if (node != null && (!matchValue || (v = node.value) == value ||                    (value != null && value.equals(v)))) {                //如果是树节点，则证明该链表已经被转换成红黑树，删除树节点                if (node instanceof HashMap.TreeNode)                    ((HashMap.TreeNode)node).removeTreeNode(this, tab, movable);                //如果该节点就是一个node对象，则把该节点的下一个节点赋给该节点对应的索引位置                //(因为如果要删除的节点等于当前节点，证明该索引位置上就一个值，                // 则当前节点的下一个节点就一定为null，这样就相当于把当前节点对应的索引位置置空)                else if (node == p)                    tab[index] = node.next;                //如果既不是树节点，也不是node对象，则要删除的节点是链表上的某一个节点，则把要删除的节点删掉(进行断链的操作)                else                    p.next = node.next;                //修改次数加一                ++modCount;                //table的实际长度减一                --size;                afterNodeRemoval(node);                return node;            }        }        return null;    }

• get(key)方法

get方法的大致流程如下：

• 计算hash值，根据hash值计算出索引位置
• 判断该索引位置的值，有如下三种情况是否是当前节点是否是红黑树上的节点，如果是根据红黑树查找是否是链表节点，如果是遍历链表
• 返回找到的节点

具体源码的注释如下：

// 1)判断key是否为空，并计算出hash值    final HashMap.Node getNode(int hash, Object key) {        HashMap.Node[] tab; HashMap.Node first, e; int n; K k;        //1)判断内部的table数组是否为空 && table数组长度是否大于0        // && (当前table的长度-1)与 hash值 相与，取出该索引位置的值first，判断是否为空        if ((tab = table) != null && (n = tab.length) > 0 &&                (first = tab[(n - 1) & hash]) != null) {            //2)判断找到的first与key是否相同，如果相同则直接返回            if (first.hash == hash && // always check first node                    ((k = first.key) == key || (key != null && key.equals(k))))                return first;            //如果步骤2的条件不满足，有一种情况是真的没有对应的值            // 还有一种情况可能是hash冲突造成的原因，也就是该first节点实际上是一个链表            // 可能所要取的值不在头节点上，这时候就要去遍历链表的每一个节点            //判断first的下一个节点是否为空，如果为空证明要找的key没有对应的值，否则进行下一步            if ((e = first.next) != null) {                //判断first是不是TreeNode节点，也就是判断该链表是否被转化成红黑树                // 如果不是进行下一步，如果是查找红黑树节点                if (first instanceof HashMap.TreeNode)                    //getTreeNode大致的方法流程如下：                    //将first节点转换成TreeNode节点，判断first节点的父节点是否为空                    // 如果为空证明该节点是根节点，如果不为空根据当前节点往上一直找，直到找到根节点                    //根据根节点遍历每一个子节点直到找到相对应的key                    return ((HashMap.TreeNode)first).getTreeNode(hash, key);                //如果不是红黑树，循环遍历链表，对每一个节点进行判断                do {                    if (e.hash == hash &&                            ((k = e.key) == key || (key != null && key.equals(k))))                        return e;                } while ((e = e.next) != null);            }        }        return null;    }

扩容机制

为什么要扩容：减少哈希冲突，提高性能

final Node[] resize() {        Node[] oldTab = table;        int oldCap = (oldTab == null) ? 0 : oldTab.length;//当前map的总长度        int oldThr = threshold;//当前map的阈值        int newCap, newThr = 0;        //1)判断当前容量是否大于0        if (oldCap > 0) {            //判断当前容量是否超过最大容量，如果超过则不继续扩容            if (oldCap >= MAXIMUM_CAPACITY) {                threshold = Integer.MAX_VALUE;                return oldTab;            }            //否则判断当前容量扩容一倍后是否小于最大容量 && 旧的容量的长度要大于默认容量16            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                    oldCap >= DEFAULT_INITIAL_CAPACITY)                //满足这两个条件，将阈值扩容一倍                newThr = oldThr << 1; // double threshold        }        //2)如果当前容量不大于0，则判断当前阈值是否大于0        else if (oldThr > 0) // initial capacity was placed in threshold            //满足则新的容量等于当前阈值的值            newCap = oldThr;        //3)如果1和2都不满足，证明这是一个新创建的map        else {               // zero initial threshold signifies using defaults            //则新的容量等于默认容量16，新的阈值等于默认的负载因子*0.75 * 默认容量16            newCap = DEFAULT_INITIAL_CAPACITY;            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);        }        // 4)判断新的阈值是否等于0        if (newThr == 0) {            //满足的话，判断新的容量是否小于最大容量            //满足的话判断新的容量*负载因子是否小于最大容量            //如果小于，那么新的阈值等于新的容量*负载因子，如果不小于，则新的阈值等于最大容量            float ft = (float)newCap * loadFactor;            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?                    (int)ft : Integer.MAX_VALUE);        }        //5)创建新的newTab表，覆盖掉原本的table        threshold = newThr;        @SuppressWarnings({"rawtypes","unchecked"})        Node[] newTab = (Node[])new Node[newCap];        table = newTab;        //6)如果旧的table表不等于空，遍历oldTab        if (oldTab != null) {            for (int j = 0; j < oldCap; ++j) {                HashMap.Node e;                //如果当前位置上的值不等于空，则将这给位置取出来赋给e，并把这个位置置空                if ((e = oldTab[j]) != null) {                    oldTab[j] = null;                    //判断e.next是否等于空，如果等于空，重新计算索引位置并赋给newTab                    if (e.next == null)                        newTab[e.hash & (newCap - 1)] = e;                    //如果不等于空，判断是否为树节点，如果是拆分树节点并重新计算索引位置，赋给newTab                    else if (e instanceof HashMap.TreeNode)                        ((TreeNode)e).split(this, newTab, j, oldCap);                    //如果不是树节点，那么就是链表                    else { // preserve order                        Node loHead = null, loTail = null;                        Node hiHead = null, hiTail = null;                        Node next;                        //循环遍历该索引位置对应的链表                        do {                            next = e.next;                            // 如果当前节点的hash值与oldTab的容量相与等于0，把该节点放到Lo的链表上                            if ((e.hash & oldCap) == 0) {                                if (loTail == null)                                    loHead = e;                                else                                    loTail.next = e;                                loTail = e;                            }                            //如果不等于0，把这个节点放到Hi的链表上                            else {                                if (hiTail == null)                                    hiHead = e;                                else                                    hiTail.next = e;                                hiTail = e;                            }                        } while ((e = next) != null);                        //循环结束后分别判断Lo和Hi是否为空，如果不为空则把Lo和Hi的头节点分别放入newTab表里                        if (loTail != null) {                            loTail.next = null;                            newTab[j] = loHead;                        }                        if (hiTail != null) {                            hiTail.next = null;                            newTab[j + oldCap] = hiHead;                        }                    }                }            }        }        //7)循环结束，扩容完成，返回新数组        return newTab;    }