HashMap-源码核心方法分析(基于Jdk8)

一.宏观结构

HashMap体量比较巨大,必须先站在远处宏观的认识它,然后逐步深入。
本文基于jdk1.8。
在这里插入图片描述
jdk1.8版本的hashmap如上图所示,是数组+链表+红黑树(之前版本没有红黑树)。
其中,

  • table数组:一段连续的地址,这里面存放是后边链表的头地址;
  • bucket: 桶,当key的hash值相同时,就只能往后排了,形成链表(链表长度大于等于默认值8,转为红黑树,小于等于6,转为链表)。
    链表中的每个节点的结构分如下4个部分(参考源码Node静态内部类):
    在这里插入图片描述
    a.hash值:就是key的hash值;
    b.key:就是键值;
    c.value:就是value;
    d.next :指向下一个节点的指针

还要注意几个概念:

  • 扩容:当hashmap中的元素数量,大于一定阈值(容量*负载因子)时,hashmap就需要进行扩容;
  • 扩容消耗性能:为啥??因为原来已经放入的对象要挪地方重新插入;为啥要挪地方,留在原地不行吗,新来的对象放在新开辟的地址中呗?不行的,因为table的地址必须是连续的(数组结构特点),假如初始大小是16,扩容之后是32,这32个地址必须也是连续的,也就是得重新找一块地方,之前那16个,也得跟着换地方了。也就是大家一起搬家住新房子,搬家肯定很麻烦的。

二.微观方法

HashMap直接看源码,发现有2000多行,其实很大部分是让人看不太懂的注释,这里直接拿掉,替换为我简单粗暴的解释,剩下的代码,一下子少了好多。
主要内容有:

  • 一些常量定义:比如默认容量等,通过这些参数,可以了解hashmap的一些特性;
  • 构造方法:简单了解下;
  • put()方法 :比较核心重要
  • 扩容方法resize():比较核心重要
  • get()方法

下面详细扒一扒,建议还是自己直接分析源码,有不懂的地方,在参考本文或者其他博客。

1.一些常量

先列举常量作用(看代码中的注释),如果对这些已经熟悉的,直接跳过。

//默认的初始化容量,16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量,2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
//负载因子,默认0.75;不建议修改
//作用:比如初始容量是16,负载因子是0.75,map的容量并不是达到16才进行扩容,而是达到16*0.75=12,就开始扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表变为红黑树的阈值
static final int TREEIFY_THRESHOLD = 8;
//红黑树变回链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
//链表转红黑树机制开启的最小数组大小,不能小于DEFAULT_INITIAL_CAPACITY*4
//作用就是当数组的长度小于64,但是tab[i]上的节点数已经大于等于8(TREEIFY_THRESHOLD)了,它也不会先转化为红黑树,而是先扩容
//只有数组长度大于64,并且节点数量大于等于8才转化为红黑树结构
static final int MIN_TREEIFY_CAPACITY = 64;

2.四个构造方法,很简单

//指定初始容量和负载因子
HashMap(int initialCapacity, float loadFactor) {
		if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        //扩容阈值,这种构造方法,开始默认为初始容量值
        this.threshold = tableSizeFor(initialCapacity);
}

//指定初始容量,使用默认负载因子0.75
HashMap(int initialCapacity) {this(initialCapacity, DEFAULT_LOAD_FACTOR);}

//使用默认初始容量16,默认负载因子0.75
HashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR; }

//从一个已有的hashmap初始化
public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

注意:当你指定一个初始容量时,比如12,但是实际上真正的初始化并不是12,而是16;因为hashmap的容量规定必须是2的次幂(考虑到性能原因,下面分析put方法时,会详细说明),当你给定的初始容量cap不是2的次幂时,计算大于cap最近的一个2次幂数值;如何计算呢,就是下面这个方法(看不懂具体算法没关系,直到方法功能就行了):

//计算>=cap的,最近的一个2的倍数
//输入7,得到8;输入12,得到16
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;
    }

3.put(K key, V value)方法

这个方法比较重要,核心部位衣服比较难扒,不要猴急,注意代码中的注释A B C …

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;
    //如果数组是空的,则直接进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //A.:::    注意(n - 1) & hash ,效果等同于同于hash%n
    //n是数组长度,hash是key的hash值
    //如果tab[i]的位置,没有存过节点,就直接把这个新节点加入进去
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
    //B. :::  如果tab[i]的位置已经有节点了,就形成链表(或者红黑树),往链表里放
        Node<K,V> e; K k;
        //B.a ::: 当tab[i]位置的节点key与要插入的节点key相同,将这个已存在的节点先赋值给变量e,后边好覆盖老节点中的value
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //B.b :::  如果tab[i]的位置节点是红黑树类型的,就往红黑树里面插入节点
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {//B.c ::: tab[i]位置key与要插入的节点key不相等,并且也不是红黑树,那说明是链表了
        	  //这里循环遍历链表,找到最后一个,将新节点插入尾部(注意jdk1.7是插入链表头部的)
            for (int binCount = 0; ; ++binCount) {
                //==null,说明是尾部了
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //B.d    如果链表长度达到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;
            }
        }
        //B.d ::: 如果要要插入的key已存在,则用新值覆盖旧值,并返回旧值  
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //C. ::: 如果 map中元素个数大于扩容阈值,进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

put步骤说明
A. 先判断tab[i]位置有没有元素,如果没有直接将新节点放入即可;hash值与数组下标的映射关系是(n - 1) & hash;
其实, (n - 1) & hash的效果,等同于hash%n(前提是n为2的次幂,比如hash=17,n=16,那么下标i就是1)
为啥不直接取余计算???因为这样&计算,效率比取余高。这就是为啥hashmap要求容量必须是2的次幂(8,16,32这样),就是为了计算数组下标时,能使用这种高效的计算方式。

B. 如果tab[i]的位置已经有节点了,就形成链表(或者红黑树),往链表里放;如果是红黑树,调用红黑树的方法,平衡插入,左旋右旋等方法,本文先不深入分析了。
B.a 当tab[i]位置的节点key与要插入的节点key相同,将这个已存在的节点先赋值给变量e,后边好覆盖老节点中的value,通过步骤B.d。
B.b 如果tab[i]的位置节点是红黑树类型的,就往红黑树里面插入节点;
B.c 如果tab[i]位置key与要插入的节点key不相等,并且也不是红黑树,那说明是链表了;那就循环遍历链表,找到最后一个节点,将新节点插入链表尾部(注意jdk1.7是插入链表头部的)
B.d 如果要插入的key已存在,则用新值覆盖旧值,并返回旧值 。
C. 如果 map中元素个数大于扩容阈值,进行扩容;这里扩容阈值在初始化的时候,=数组长度,扩容一次之后,重新赋值为数组长度*负载因子。

4.resize(),扩容

当map中的元素个数大于扩容阈值,就需要进行扩容了。
这个方法同样比较重要,核心部位衣服比较难扒,不要猴急,注意代码中的注释A B C D …

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    //A.:::扩容之前容量是否大于0
    if (oldCap > 0) {
        //A.a:::如果扩容之前就是最大容量了,就算了,直接返回
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //A.b:::新容量等于oldCap*2,新阈值等于oldThr*2,但都不能大于最大默认值
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    /B.:::hashmap初始化的时候,容量为0,直接让容量等于阈值
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
    //C.::: 也就是说初始化hashmap的时候,如果不指定容量,使用默认值
        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) {
        //D.:::  老的数组不是null,那么就遍历老数组,挨个处理吧
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            //D.a:::  如果数组中内容是null,就不需要处理;直接下一个循环
            if ((e = oldTab[j]) != null) {
            	//D.b::: 如果不是空,将老位置置空,相当于释放内存
                oldTab[j] = null;
                if (e.next == null)
                //如果tab[i]位置只有一个节点,后边都是空,那么将此节点重新计算哈希存入新table中即可
                    newTab[e.hash & (newCap - 1)] = e;
                //D.c:::  如果是红黑树结构,遍历分解红黑树
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                //D.d:::  链表,则遍历每个元素,重新插入newTab
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        // 这个判断比较重要, e.hash & oldCap的效果等同于hash除以oldCap,商是偶数的
                        //符合这个条件的元素,下标不变,不符合条件的,下标+oldCap
                        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步骤说明
A. 扩容之前容量是否大于0
A.a 如果扩容之前就是最大容量了,就算了,直接返回
A.b 新容量等于oldCap2,新阈值等于oldThr2,但都不能大于最大默认值
B. hashmap初始化的时候,容量为0,直接让容量等于阈值
C. 说初始化hashmap的时候,如果不指定容量,使用默认值
以上是容量阈值初始化过程;
以下是真正扩容方法
D. 如果老的数组不是null,那么就遍历老数组,挨个处理吧
D.a 如果数组中内容是null,就不需要处理;直接下一个循环
D.b 如果不是空,将老位置置空,相当于释放内存
D.c 如果是红黑树结构,进入红黑树中遍历,具体同D.d,把红黑树中的元素拆分两部分,拆完后如果元素小于6,调整为链表。
D.d 如果是链表,则遍历每个元素,重新插入newTab;那具体下标如何重新分配呢?规则很简单:
e.hash & oldCap==0这个判断比较重要, 效果等同于hash除以oldCap,商是偶数的;符合这个条件的元素,下标不变,不符合条件的,下标+oldCap。

比如,原来容量是16,扩容之后肯定是32;我们把这32分为两部分,下标0-15和16-31;hash值除以16,商是偶数的元素,其在新tab中的下标不变,比如hash=13,之前在tab[12]的位置,那么扩容之后,他还在这个位置;
再比如hash=17,之前在tab[1]的位置,扩容之后,他在tab[1+16]的位置。

注意:
在jdk1.7中的扩容,移动老数据到新的table中,如果发生hash冲突,后面链表是头插法,在多线程并发场景下,会出现循环列表进而导致死循环;同时也会出现插入覆盖的问题;
在jdk1.8中,采用尾插法,避免了死循环的问题,但是在多线程并发场景,依然会出现插入覆盖的问题;

5.get(Object key),获取元素

get方法相对比较简单。

public V get(Object key) {
   Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
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) {
        //A.:::根据hash,得到tab[i]位置第一个元素,如果是要找的,直接返回
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
        	//B.:::如果tab[i]是红黑树,遍历红黑树
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
            //C.::否则就是链表,那么就遍历链表
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

步骤说明:
A.:::根据hash,得到tab[i]位置第一个元素,如果是要找的,直接返回
B.:::如果tab[i]是红黑树,遍历红黑树
C.::否则就是链表,那么就遍历链表

本文就蹂躏到这里吧,已经比较持久了,还有一私密的地方,后续在慢慢探索噢~

参考文章
https://www.cnblogs.com/leesf456/p/5242233.html

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值