HashMap源码分析

最新推荐文章于 2023-03-27 17:08:56 发布
最新推荐文章于 2023-03-27 17:08:56 发布
阅读量153 收藏
点赞数 1
分类专栏： 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39352976/article/details/79961245
版权

前言：HashMap的用法是相当的广泛，之前就是用get和put，根本不了解其原理，现在随着工作的需要是必须要了解其原理的。我这里的源码是基于java8来分析的。通过本文的介绍，我们突然发现我们在大学学习的数据结构(链表，数组，二叉树等)的知识用到了，看来大学的理论课程对我们的工作是有帮助的。

java8中的HashMap的结构是有数组、单链表以及红黑树组成的，如果链表的节点个数大于8则分裂为红黑树，如下图： 
这里写图片描述 
图片是copy过来的。

HashMap的主要属性如下：

//默认的容量，即默认的数组长度 16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//最大的容量，即数组可定义的最大长度 
static final int MAXIMUM_CAPACITY = 1 << 30;
//链表分裂为红黑树的阈值
 static final int TREEIFY_THRESHOLD = 8;
//实际存储的键值对个数
transient int size;
//用于迭代防止结构性破坏的标量
transient int modCount;

transient Node<K,V>[] table;//存放链表的数组

table 的类型是Node

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;//当发生hash碰撞是指向下一个节点(Node)

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
        ......

    }

下面开始分析常用的api，一般我们都是这样使用HashMap的，如下：

Map<String, String> map = new HashMap<String, String>();
map.put("apple", "1");
map.get("apple");
map.remove("apple");

先来分析put方法：

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

其中的hash(String key)代码如下：

static final int hash(Object key) {
int h;
//如果key != null那么将key的hashCode 异或 key的hashCode右移16位
//右移就是将高位补0，这样做的目的就是保持hash值是相对均匀分布的
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

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;
        //如果table 为空或者 tab.length = 0 ，那么执行resize()方法，这个方法就是初始化table的，稍后再讲
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //根据键的 hash 值找到该键对应到数组中存储的索引，如果为 null，那么说明此索引位置并没有被占用
        //在该索引位置插入Node
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //不为 null，说明此处已经被占用，只需要将构建一个节点插入到这个链表的尾部即可
        else {
            Node<K,V> e; K k;
            //如果两次插入的数据的key的hash值以及key都相等，那么是一次修改操作
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //如果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 ，将链表裂变成红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //如果两次插入的数据的key的hash值以及key都相等，那么是一次修改操作
                    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;
                //该方法在HashMap的子类LinkedHashMap中实现了，这里为空方法
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //如果添加后，数组容量达到阈值，进行扩容
        if (++size > threshold)
            resize();
        //该方法在HashMap的子类LinkedHashMap中实现了，这里为空方法
        afterNodeInsertion(evict);
        return null;
    }

上面虽然注释了，但是大家应该还是不理解的，后面会写例子一步一步进行分析，请耐心的看下出，你也会透彻理解HashMap的。当然了红黑树那一块我就不说了，说不清楚，哈哈。我们接下来看table初始化的方法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;
        }

        else if (oldThr > 0)
            newCap = oldThr;
            //数组未初始化并且阈值也为0，说明一切都以默认值进行构造
        else {
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //这里也是在他偷懒的后续弥补
        //newCap = oldThr 之后并没有计算阈值，所以 newThr = 0
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                    (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;

        //根据新的容量初始化一个数组
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        //旧数组不为 null，这次的 resize 是一次扩容行为
        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;
                        //如果 e 是红黑树结点，红黑树分裂，转移至新表
                    else if (e instanceof TreeNode)
                        ((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
                        //这部分是将链表中的各个节点原序地转移至新表中，我们后续会详细通过例子来说明
                    else {
                        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;
        }

下面我们开始以实例来分析了，为了方便说明，我这里的数组长度为4，假设我们要put3个元素，3个元素的key分别为 m，n和t；假设m的计算出来的hash值为5， n的计算出来的hash值为6，t的计算出来的hash值为9，

首先 put 数据key 为m; 
由于是第一次put数据，所以会走到resize方法： 
第2行 ：table赋值给oldTab，由于第一次table未初始化， table = null。 
第3行：int oldCap = (oldTab == null) ? 0 : oldTab.length; 由于oldTab = null，所以 oldCap = 0； 
第4行：int oldThr = threshold; threshold为赋值所以为0 
所以会走到16行的else语句： 
newCap = DEFAULT_INITIAL_CAPACITY;//原本是16，我们这里为了方便 值为4 
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//原本的阈值为16*0.75 = 12，现在是 4*0.75=3；走到第24行 
第24行： threshold = newThr;即阈值为4 
第26行：Node<>[] newTab = (Node<>[])new Node[newCap]; //newTab 为数组大小为4的Node型数组。 
第27行：table = newTab; 
第28行：if (oldTab != null) {…}，//上面已经分析 oldTab 为null，条件不成立。直接return newTab； 
然后回到putVal的方法。

putVal方法分析： 
由于第一次put，所以table为null，走到resize()方法后，table的size为4(4是我这里为了方便讲解设置的值，上面有讲到) 
第4行：if ((tab = table) == null || (n = tab.length) == 0) //由于table为空 执行第5行 
第5行：n = (tab = resize()).length; //在初始化数组后，n = 4 
第6行：if ((p = tab[i = (n - 1) & hash]) == null)//我们之前说过了要插入3个数据m、n和t，他们的hash值分别是5,6,9； 
先插入m，m的hash值是5 ，由于n=4，(n-1)&hash = 0011 & 0101=1;由于是第一次插入数据，table[1]的位置上没有赋值，所以执行第7行 
第7行：tab[i] = newNode(hash, key, value, null);//new 一个Node放到table数组索引为1的位置上。 
然后我们看第35行： 
第35行： if (++size > threshold) //如的数据大于阈值就调用resize()方法扩容，显然这次if条件不成立。 (之前说了阈值是 4*0.75=3)；

接着putkey为n的数据，走到putVal方法的第四行： 
第4行：if ((tab = table) == null || (n = tab.length) == 0) //由于之前put数据m的时候，table已经初始化过了，那么直接走到第6行； 
第6行：if ((p = tab[i = (n - 1) & hash]) == null)// 之前假设数据n的hash值为6，那么(n-1)&hash = 0011&0110 = 2; 由于table[2]上之前没有存放数据，那么if()的条件成立。走到第7行 
第7行：tab[i] = newNode(hash, key, value, null);//new 一个Node放到table数组索引为2的位置上。 
第35行： if (++size > threshold) ；//由于size=2，所以if条件不成立，不会进行扩容操作；

最后put数据t，t的hash值之前假设为9. 
走到代码第4行。 
第4行：if ((tab = table) == null || (n = tab.length) == 0) //由于之前put数据m的时候，table已经初始化过了，那么直接走到第6行； 
第6行：if ((p = tab[i = (n - 1) & hash]) == null)// 之前假设数据n的hash值为9，那么(n-1)&hash = 0011&1001 = 1; 由于table[1]上之前已经存放了数据m，所以if条件不成立。这里就是人们常说的发生hash碰撞了，那么走到else中，看第10行： 
第10行：if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))//这里put数据的hash为9,与table[1]的数据m的hash值5是不相等的，那么走到13行： 
第13行： else if (p instanceof TreeNode)//这里P的节点不是红黑树类型所以执行第15行的else中去。

我先画张图，表示table表中的数据。

这里写图片描述

进入for循环： 
if ((e = p.next) == null)// p是等于tab[i = (n - 1) & hash])，上面分析(n - 1) & hash = 1，即p指向table[1],如下图： 
这里写图片描述

由于table[1]没有后续节点，所以if ((e = p.next) == null)成立，进入18行： 
第18行： p.next = newNode(hash, key, value, null);//就是让p的next指向一个新的节点，新的节点里面的数据就是刚put进来的t，这个是很简单的数据结构的单链表操作。如下图： 
这里写图片描述

最后走到35行：if (++size > threshold)//由于++size=3且threshold=3，所以本次put操作不会产生扩容操作。

假设我们再put一个key 为 r数据，r的hash等于12（二进制 ：1100）， 
会走到：if ((p = tab[i = (n - 1) & hash]) == null) // (n-1)&hash = 0011&1100 = 0,由于table[0]上没有数据，所以if条件成立： 
tab[i] = newNode(hash, key, value, null);//将刚put的数据放到table[0]上，如下图， 
这里写图片描述 
接着走到35行： 
第35行：if (++size > threshold) //size=4> threshold=3,所以进行扩容，即执行resize().

再来看resize()代码： 
第1行：Node<,>[] oldTab = table;//将table赋值给oldTab ,table的长度是4 
第3行： int oldCap = (oldTab == null) ? 0 : oldTab.length;// oldTab.length = 4 
第4行：int oldThr = threshold;// oldThr 等于threshold = 3 
第5行：int newCap, newThr = 0;// newCap和newThr 都等于0 
第6行：if (oldCap > 0) //oldCap = 4，条件成立，走到7行 
第7行：if (oldCap >= MAXIMUM_CAPACITY)// MAXIMUM_CAPACITY = 2的30次方，所以不成立。走到16行else语句 
16行：else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && 
oldCap >= DEFAULT_INITIAL_CAPACITY)//newCap 等于oldCap 左移1，即newCap = oldCap *2 = 8，我们这里的DEFAULT_INITIAL_CAPACITY默认为4，这是我开始为了讲解简单设定的，本来是16。所以条件成立。 
第18行：newThr = oldThr << 1;//newThr = oldThr 左移1，即等于oldThr *2 = 3*2=6。接着看第24行。 
第24行：threshold = newThr;//threshold = 6 
第26行：Node<,>[] newTab = (Node<,>[])new Node[newCap];//new 了一个Node型数组，数组的个数为newCap = 8。 
第27行：table = newTab;//将table赋值为newTab 
第28行：if (oldTab != null)//oldTab 在方法的第一行就赋值了，就是之前个数为4的table，就是上面put了四个数据的table，如上图。 
接下来是for循环遍历oldTab 中所有的数据，走到31行 
第31行：if ((e = oldTab[j]) != null)//for循环开始j=0,oldTab[j])中存放的key为r的数据，所有不为null，条件成立。走到32行 
第32行：oldTab[j] = null;//oldTab[0]=null 
第34行： if (e.next == null)//由于oldTab[0]上并未添加其他的数据，所以e.next == null，条件成立。 
第35行：newTab[e.hash & (newCap - 1)] = e;// e.hash = 10， newCap = 8 ，e.hash & (newCap - 1) = 1010&0111= 0100 = 2，即将e放到newTab的索引等于2的位置上，如下图： 
这里写图片描述

再for循环 j = 1: 
if ((e = oldTab[j]) != null)// 由于oldTab[1]上有key为m的数据，所有条件成立。 
第32行：oldTab[j] = null;//oldTab[1]=null 
第34行： if (e.next == null)//由于e.next上有key为t的数据，所以条件不成立。 
走到36行：else if (e instanceof TreeNode) //由于e不是红黑树所以条件不成立，走到38行的else中： 
首先，定义几个变量： 
Node<, > loHead = null, loTail = null; 
Node<, > hiHead = null, hiTail = null; 
Node<, > next; 
这个我得用图来表示了，e等于oldTab[1]，如下图： 
这里写图片描述 
然后执行do …while：如下： 
第41行：next = e.next;如下图： 
这里写图片描述 
第42行：if ((e.hash & oldCap) == 0) // e.hash&oldCap = 0101&0100= 0100=4，if条件不成立，走到46行else 
第46行：if (hiTail == null)//由于hiTail 初始化为null，所以条件成立，走到48行 
第47和49行行：hiHead = e;hiTail = e;如下图： 
这里写图片描述

执行 while ((e = next) != null); //将next 赋值给 e，从图上可以看 next 存放的是key为t的数据，所以 while条件成立，继续执行do语句，如下图： 
这里写图片描述

接着执行 do 里面的语句，如下， 
next = e.next;//从上图可知 e.next 没有数据了，所以 next = null； 
if ((e.hash & oldCap) == 0) // e.hash & oldCap = 1001&0100 = 0，if条件成立，执行下面的语句。 
if (loTail == null) //loTail 初始化为null，条件成立，执行如下语句： 
loHead = e;和 loTail = e;执行完如下图。 
这里写图片描述

接着执行while ((e = next) != null);//上面 next = null，所以 e = next = null，跳出do…while循环。如下图，e = null了。 
这里写图片描述 
第52行 ： if (loTail != null)//从上图可知loTail 不为null，条件成立。走如下代码： 
loTail.next = null;//loTail的next指针置空 
newTab[j] = loHead;//将loHead指向的key为t的数据放到newTab[1]里面，如下图： 
这里写图片描述

接着执行如下语句： 
if (hiTail != null)//从上面的图我们可以看出 hiTail 指向key为m的结点，所以if条件成立，执行如下语句： 
hiTail.next = null;//hiTail的next指针置空 
newTab[j + oldCap] = hiHead;//将hiHead执行的数据放入newTab[1+4]中，如下图： 
这里写图片描述

接着执行 j = 2: 
if ((e = oldTab[j]) != null)//oldTab[2])里面存放的是key为n的数据，所以if条件成立，且e 执行oldTab[2])的元素，如下图： 
这里写图片描述

接着执行： oldTab[j] = null;//将oldTab[2]置空，然后执行： 
if (e.next == null) //因为e指向的数据oldTab[2]并未发生hash碰撞，所以没有形成单链表，所以e.next = null，条件成立： 
newTab[e.hash & (newCap - 1)] = e; // newCap = 8, e.hash & (newCap - 1) = 0110& 0111 = 0110 = 6;即将e放到newTab[6]中，如下图： 
这里写图片描述

着讲get以及remove方法：

我们还是用上次的数据，即有3个数据，3个数据的key分别为 m，n，t，对应的hash值分别为5，6，9。如下图： 
这里写图片描述

一 、get方法 ：

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

getNode方法如下：

 final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        //如果tab不为null且tab中有数据且tab相应索引的位置上的数据不为null
        if ((tab = table) != null && (n = tab.length) > 0 &&
                (first = tab[(n - 1) & hash]) != null) {
            //如果key的hash值相等且key也相等，那么直接返回这个相应的值
            if (first.hash == hash && // always check first node
                    ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            //如果上面的条件不满足且first的next指向的数据不为null
            if ((e = first.next) != null) {
                //如果first是红黑树类型，则以红黑树的方式查找该节点
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)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;
    }

上面的代码都有注释了，还是一点点的来分析下： 
假设我们现在想get key为t的数据： 
第3行： if ((tab = table) != null && (n = tab.length) > 0 && 
(first = tab[(n - 1) & hash]) != null) //table中有3个数据，所以tab不为null，n是tab的长度，等于4，(n - 1) & hash = 0011&1001=1；由于tab[1]不为null，所以if条件成立，first指向tab[1]，如下图： 
这里写图片描述

第5行：if (first.hash == hash && // always check first node 
((k = first.key) == key || (key != null && key.equals(k)))) 
由上图可知first指向数据的hash值为0101，而我们想要get的数据的key为t，hash值为1001，所以if条件不满足，走到第8行。

第8行：if ((e = first.next) != null) // e = first.next，即e指向first为头结点的链表的下一个结点，如下图： 
这里写图片描述

可知if条件成立，走到第9行，判断 first 是否是红黑树类型，显示是单链表类型，所以条件不成立，走到第11行的do…while

第12行：if (e.hash == hash && 
((k = e.key) == key || (key != null && key.equals(k)))) 
由上图可知，e的hash值等于1001等于我们要get的数据的hash值，并且key值相等，所以条件成立，返回 key为t的数据。循环结束，如果还没找到数据的话就接着遍历该链表的下一个数据，直到找到该数据。

到这里，get的方法讲完了，我来写个我之前遇到的例子，大家运行的结果是啥？

 Map<Long, String> map1 = new HashMap<Long, String>();
        map1.put(1L, "abc");
        System.out.println(" map1 val = " + map1.get(1));

可能有的人直到答案是null了，有些人可能还不知道，一起来看看啊。 
我们先来打印几个值看看：

Long a1 = 1l;
        Integer a2 = 1;
        System.out.println("a1.hashCode = " + a1.hashCode()+", a2.hashCode = "+a2.hashCode());
        System.out.println("a1.equals(a2) = "+a1.equals(a2));

结果如下：

a1.hashCode = 1, a2.hashCode = 1
a1.equals(a2) = false
  • 1
  • 2
  • 3

我们put进去的key为Long类型，而get的时候用的却是Integer类型，从打印的结果来看，a1是Long型，a2是Integer类型，a1和a2的hashcode 是相等的，那么通过hash(key)方法获取的hash值肯定也是相等的。但是a1和a2通过equals判断的结果是false。可以看到getNode方法的第5行； 
第5行：if (first.hash == hash && // always check first node 
((k = first.key) == key || (key != null && key.equals(k)))) //从上面的分析可知((k = first.key) == key || (key != null && key.equals(k))是不成立的，所以返回的是null。

二、remove方法

代码如下：

public V remove(Object key) {
        Node<K,V> e;
        //如果找到要remove的数据则返回该数据的value，否则返回null
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

主要看看里面的removeNode方法：

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;
        //如果tab不为null且tab中有数据且tab相应索引的位置上的数据不为null
        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;
            //如果key的hash值相等且key也相等，那么将p赋值给node
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            //如果条件不成立，如果p是红黑树类型则通过红黑树的方式找到 node，
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                //否则以遍历链表的方式找到该node
                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);
                }
            }
            //找到待删除的结点后，执行的链表删除操作，等下会有实例分析
            if (node != null && (!matchValue || (v = node.value) == value ||
                    (value != null && value.equals(v)))) {
                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;
                //这个方法这hashmap的子类linkhashmap中实现了，在hashmap里是一个空方法
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

原始数据还是之前的3个，假设我想删除的数据是key为m，hash值为0101的数据。 
看removeNode的第4行代码；

第4行：if ((tab = table) != null && (n = tab.length) > 0 && 
(p = tab[index = (n - 1) & hash]) != null) //table中有3个数据，table的长度为4，index = (n - 1) & hash = 0011&0101=1，table[1]中存放的是key为m的数据，所以 
if条件成立，p指向table[1]，如下图： 
这里写图片描述

接下来走到第6行， 
第6行： if (p.hash == hash && 
((k = p.key) == key || (key != null && key.equals(k)))) // 由上图可知p的hash值为0101，key为m，是我们想要删除的数据，所以该条件成立。走到第8行；

第8行：node = p; //node 指向结点p，如下图： 
这里写图片描述

第21行： if (node != null && (!matchValue || (v = node.value) == value || 
(value != null && value.equals(v)))) // 由上图可知node指向table[1]，而matchValue 是false，后面的条件可不看了，if条件成立。

第22行：if (node instanceof TreeNode) //不成立，

第24行：else if (node == p) //由上图可知 node == p成立，

第25行：tab[index] = node.next; //index上面分析了等于1，而node.next指向key为t的数据。即tab[1]存放key为t的数据，如下图： 
这里写图片描述

假设我们删除的是key为 t 的数据，table中还是之前的3个数据。 
前面几行的逻辑如上，但第6行条件却不成立了， 
第6行： if (p.hash == hash && 
((k = p.key) == key || (key != null && key.equals(k)))) //此是p指向的是table[1]，p的hash= 0101，而我们要删除的数据key等于t，hash值等于1001，所以if条件不成立。走到第9行；

第9行： else if ((e = p.next) != null) //e=p.next p指向table[1]的第一个数据，p.next指向的是key为t的数据，所以 e 指向key为t的数据，如下图： 
这里写图片描述

该if条件成立，第10行p是否是红黑树类型，不满足；走到12行执行do…while操作，如下：

第14行 ： if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) // e指向的结点的key为t，hash值为1001就是我们要删除的数据，条件满足，走到下一行： 
node = e; //node 结点执行e，如下图： 
这里写图片描述

然后执行break;跳出循环。 
接着执行21行的if语句，上面分析了，该if成立，由于 node 不是红黑树类型的结点，所以走到24行：

第24行：else if (node == p) //上图可知，node不等于p，走到下一行 
第26行：p.next = node.next; //node后面没有数据，所以node.next指向为空，即将p结点的next指向为空，就变成下图的结果： 
这里写图片描述

最后返回被删除的结点 node。

HashMap的主要操作就是这样的了，后续会介绍LinkHashMap，里面涉及到双向的循环链表，这个得有一定的数据结构基础才行，不然可能会有点懵逼，可能我写的不大好，欢迎指正。


阳光的亮亮
关注
专栏目录
Java中的HashMap源码分析
Palpitate_fx的博客
03-27 967
目录 HashMap的继承体系 什么是Map 哈希表 存储结构 HashMap的属性 Node内部类 HashMap的构造方法 数组容量的计算 put( K key,V value)方法 HashMap的扩容机制 HashMap新的数组的填充 HashMap的get操作 HashMap 中的红黑树 散列冲突解决方式 HashMap的继承体系 1.HashMap实现了Serializable接口，可以被序列化 2.HashMap实现了Cloneable接口，可..
HashMap源码分析(超级详细)
V539413949的博客
04-14 667
1.HashMap简介 HashMap基于哈希表的Map接口实现，是以key-value存储形式存在。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。) 1.2 HashMap数据结构 在 JDK1.8 中，HashMap 是由 数组+链表+红黑树构成，新增了红黑树作为底层数据结构，结构变得复杂了，但是效率也变的更高效。当一个值中要存储到Map的时候会根据Key的值来计算出他的 hash，通过哈希来确认到数组的位置，如果发生哈希碰撞就以链表的形式存储 在Objec
HashMap 源码分析
搬运Gong
04-03 604
HashMap 源码分析，动态扩容以及链表、红黑树之间的转换过程
java HashMap 源码分析（深度讲解）
最新发布
Cyan_RA9的博客
03-27 1629
java 集合篇章——HashMap源码分析（非常详细）。
Rust HashMap 源码分析
今天你emo了吗？
06-03 703
Rust HashMap 源码分析1 HashMap 数据结构 1 HashMap 数据结构 use hashbrown::hash_map as base; #[derive(Clone)] pub struct RandomState { k0: u64, k1: u64, } pub struct HashMap<K, V, S = RandomState> { base: base::HashMap<K, V, S>, } HashMap 有三个
HashMap 源码分析1.8
weixin_45706854的博客
06-26 843
HashMap 源码分析 简介 HashMap 是 Java 语言中常用的用于存放键值对数据类型的集合类。 随着 JDK（Java Developmet Kit）版本的更新，JDK 1.8 对 HashMap 底层的实现进行了优化，底层实现也由之前的 数组 + 链表 改为 数组 + 链表 + 红黑树 。 HashMap 的常用方法如下： //创建一个 map Map<String, String> map = new HashMap<>(); //如果 key 不存在则插入数据，如
【数据结构-源码分析】HashMap源码分析(超级详细）
fearless的博客
01-03 1382
HashMap基于哈希表的Map接口实现，是以key-value存储形式存在。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同)。在 JDK1.8 中，HashMap 是由数组 + 链表 + 红黑树构成，新增了红黑树作为底层数据结构，结构变得复杂了，但是效率也变的更高效。当一个值中要存储到Map的时候会根据Key的值来计算出他的hash，通过哈希来确认到数组的位置，如果发生哈希碰撞就以链表的形式存储。当链表长度过长时，HashMap会把这个链表转换成红黑树来存储。
HashMap 源码分析(JDK1.8)
huangshanchun的专栏
12-30 1160
HashMap是Java程序员使用频率最高的容器之一，主要原因它的查询效率比较高，本文基于JDK1.8，深入探讨HashMap的结构实现和功能原理。
线上收单和线下收单的区别
热门推荐
技术成就人生
02-27 2万+
1，支付方式：网关支付，快捷支付，代扣，代付，POS线下支付  网关支付和网银支付的区别：  网银支付是银行金融网络系统和Internet网络之间的接口，是由银行操作的。将Internet上传的数据转化为银行金融机构内部数据的一组服务器设备。（网银支付前提是需要开通网银）  网关支付是指第三方支付公司接入银行网银接口后，对银行来说是对外开放了一个网银接口，对第三方支付公司来说，这种模式就是网关支付...
第三方支付平台涉及到的业务
技术成就人生
02-27 7904
1，结算类型：对公，对私是什么意思？   对公，就是以公司与第三方支付公司签约，提供公司的对公账户。第三方支付公司直接将收款结算到公司对公账户。   对私，就是以个人与第三方支付公司签约，提供个人账户，第三方支付公司直接将收款结算到您的个人账户。如果是公司签约，又想结算至个人账户，这种情况，叫做代付或者分账。需要一定的手续费，一般为每笔不超过5万元，每笔收费50元。2，T0结算,T1结算,D0结算...
jsp自定义标签总结
技术成就人生
02-24 5711
一、概述 JSP 2.0 中提供了两种新的开发自定义标记的方法：1、简单标签机制SimpleTagJSP 2.0 中加入了新的创建自定义标记的API：javax.servlet.jsp.tagext.SimpleTag，该API 定义了用来实现简单标记的接口。和JSP 1.2 中的已有接口不同的是，SimpleTag 接口不使用doStartTag()和doEndTag()方法，而提供了一个简单的...
Oracle中恢复drop掉的表中的数据
技术成就人生
02-24 4837
在oracle10g中,如果不小心drop掉一张表,能不能恢复呢?     答案是肯定的,在oracle10g中,当使用命令drop table tablename 命令时,其实不会真正的删除该表,而是把表放到了回收站中(回收站的概念类似windows中的回收站),所以我们可以通过flashback命令来恢复drop掉的表,下面就该问题做一个小小的研究。我们先创建一张表Create table t...
request和response对象方法总结
技术成就人生
02-28 4417
request方法列举：request.getAuthType() // 获取保护servlet的认证方案名(BASIC或SSL),未受保护的servlet返回的就是nullrequest.getCharacterEncoding() // 获取字符编码request.getContentLength()// 返回请求体内容的长度request.getContentType() // 获取内容类型...
Storm实时数据处理
技术成就人生
02-26 3724
Storm实时数据处理参考：http://ifeve.com/getting-started-with-stom-index/一，storm概念         Storm是一个分布式的，可靠的，容错的数据流处理系统。它会把工作任务委托给不同类型的组件，每个组件负责处理一项简单特定的任务。Storm集群的输入流由一个被称作spout的组件管理，spout把数据传递给bolt， bolt要么把数据保...
生成(批量)二维码代码
技术成就人生
02-24 2799
需要导入google的zxingCore .jar包// 生成二维码图片 public ActionForward createTwoCodeImg(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) { String forward = "mess...
springboot实现定时器功能
技术成就人生
02-27 2620
springboot封装了quartz1，scheduled.properties，定时配置文件配置 pay_order_risk_task.cron = 0 0/1 * * * ?2，定时任务服务@PropertySource("classpath:scheduled.properties")@C...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值