• jdk1.8-HashMap源码分析


    本文适当参考了以下几篇博客:
    感谢!!

    以下内容是加上自己翻看源码理解整理而得,有点乱,以后有空再整理下:
    一:关于HashMap的几个总结
    1.HashMap的key和value都允许为null
    2.HashMap不保证映射的顺序
    3.HashMap不是同步的

    二:我们看下HashMap的类关系

    我们可以看到:
    public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
    1.继承于抽象类AbstractMap
    2.实现Map接口、Cloneable和Serializable接口

    三:主要的类成员属性
    /**
    * 默认的初始化容量,1 << 4 左移四位相当于 1 * 2 ^ 4 值为16
    * 必须是2的n次幂
    */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
    *
    * 最大容量为1<<30,即2的30次方
    */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
    * 默认的加载因子
    */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
    * 将链表转为红黑树的临界值
    *
    */
    static final int TREEIFY_THRESHOLD = 8;

    /**
    * 恢复成链式结构的桶大小临界值
    * 小于TREEIFY_THRESHOLD,临界值最大为6
    */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
    * 桶可能被转化为树形结构的最小容量。当哈希表的大小超过这个阈值,才会把链式结构转化成树型结构,否则仅采取扩容来尝试减少冲突。
    * 应该至少4*TREEIFY_THRESHOLD来避免扩容和树形结构化之间的冲突。
    */
    static final int MIN_TREEIFY_CAPACITY = 64;


    分析:上面提高了两个概念,初始容量和加载因子
    这两个参数是影响HashMap性能的重要参数,其中容量表示哈希表中桶的数量,初始容量是创建哈希表时的容量,加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度,它衡量的是一个散列表的空间的使用程度,负载因子越大表示散列表的装填程度越高,反之愈小。对于使用链表法的散列表来说,查找一个元素的平均时间是O(1+a),因此如果负载因子越大,对空间的利用更充分,然而后果是查找效率的降低;如果负载因子太小,那么散列表的数据将过于稀疏,对空间造成严重浪费。系统默认负载因子为0.75,一般情况下我们是无需修改的

    这里我们有必要先认识下HashMap的数据结构,以便更好的分析源码

    在分析HashMap源码之前,有必要了解HashMap的数据结构,否则很难理解下面的内容。


    ps:图片来自网上,感觉这个图画的不错。


    从上图中可以很清楚的看到,HashMap的数据结构是数组+链表+红黑树(红黑树since JDK1.8)。我们常把数组中的每一个节点称为一个。当向桶中添加一个键值对时,首先计算键值对中key的hash值,以此确定插入数组中的位置,但是可能存在同一hash值的元素已经被放在数组同一位置了,这种现象称为碰撞,这时按照尾插法(jdk1.7及以前为头插法)的方式添加key-value到同一hash值的元素的后面,链表就这样形成了。当链表长度超过8(TREEIFY_THRESHOLD)时,链表就转换为红黑树。


    这里的核心其实就是节点数组
    Node<K,V>[]
    然后每个节点Node对象如下:
    **
    * 静态内部类,Node节点
    */
    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;
    }
    }



    四:构造函数
    1.无参构造方法
    /**
    * Constructs an empty <tt>HashMap</tt> with the default initial capacity
    * (16) and the default load factor (0.75).
    */
    public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
    分析:构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。注意初始容量需要第一次使用的时候,才会进行初始化

    2.HashMap(int initialCapacity):构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap
    /**
    * Constructs an empty <tt>HashMap</tt> with the specified initial
    * capacity and the default load factor (0.75).
    *
    * @param initialCapacity the initial capacity.
    * @throws IllegalArgumentException if the initial capacity is negative.
    */
    public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    分析:传入指定的初始容量initialCapacity,同时传入默认加载因子,调用this方法
    /**
    * Constructs an empty <tt>HashMap</tt> with the specified initial
    * capacity and load factor.
    *
    * @param initialCapacity the initial capacity
    * @param loadFactor the load factor
    * @throws IllegalArgumentException if the initial capacity is negative
    * or the load factor is nonpositive
    */
    public HashMap(int initialCapacity, float loadFactor) {
    //如果初始容量小于0,报错
    if (initialCapacity < 0)
    throw new IllegalArgumentException("Illegal initial capacity: " +
    initialCapacity);
    //大于最大容量,直接等于最大容量
    if (initialCapacity > MAXIMUM_CAPACITY)
    initialCapacity = MAXIMUM_CAPACITY;
    //加载因子小于等于0或则加载因子不是数字抛错(isNaN 实际上就是 Not a Number的简称。0.0f/0.0f的值就是NaN,从数学角度说,0/0就是一种未确定)
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
    throw new IllegalArgumentException("Illegal load factor: " +
    loadFactor);
    this.loadFactor = loadFactor;
    //阈值 等于 initialCapacity最小的二次幂数值。
    this.threshold = tableSizeFor(initialCapacity);
    }
    分析:校验初始容量和加载因子,最后threshold阈值等于调用tableSizeFor()方法返回的值,tableSizeFor()返回的是大于等于初始化容量的最小二次幂数值。

    继续看下tableSizeFor()方法
    /**
    * Returns a power of two size for the given target capacity.
    * 返回大于等于cap的最小的二次幂数值。
    */
    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的最小的二次幂数值
    类似如下:

    来看下ArrayDeque是怎么做的吧:

    private void allocateElements(int numElements) {
        int initialCapacity = MIN_INITIAL_CAPACITY;
        // Find the best power of two to hold elements.
        // Tests "<=" because arrays aren't kept full.
        if (numElements >= initialCapacity) {
            initialCapacity = numElements;
            initialCapacity |= (initialCapacity >>>  1);
            initialCapacity |= (initialCapacity >>>  2);
            initialCapacity |= (initialCapacity >>>  4);
            initialCapacity |= (initialCapacity >>>  8);
            initialCapacity |= (initialCapacity >>> 16);
            initialCapacity++;
    
            if (initialCapacity < 0)   // Too many elements, must back off
                initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
        }
        elements = new Object[initialCapacity];
    }
    

    看到这段迷之代码了吗?在HashMap中也有一段类似的实现。但要读懂它,我们需要先掌握以下几个概念:

    • 在java中,int的长度是32位,有符号int可以表示的值范围是 (-2)31 到 231-1,其中最高位是符号位,0表示正数,1表示负数。

    • >>>:无符号右移,忽略符号位,空位都以0补齐。

    • |:位或运算,按位进行或操作,逢1为1。

    我们知道,计算机存储任何数据都是采用二进制形式,所以一个int值为80的数在内存中可能是这样的:

    0000 0000 0000 0000 0000 0000 0101 0000

    比80大的最近的2次幂是128,其值是这样的:

    0000 0000 0000 0000 0000 0000 1000 0000

    我们多找几组数据就可以发现规律:

    • 每个2的次幂用二进制表示时,只有一位为 1,其余位均为 0(不包含符合位)

    • 要找到比一个数大的2的次幂(在正数范围内),只需要将其最高位左移一位(从左往右第一个 1 出现的位置),其余位置 0 即可。

    但从实践上讲,没有可行的方法能够进行以上操作,即使通过&操作符可以将某一位置 0 或置 1,也无法确认最高位出现的位置,也就是基于最高位进行操作不可行。

    但还有一个很整齐的数字可以被我们利用,那就是 2n-1,我们看下128-1=127的表示形式:

    0000 0000 0000 0000 0000 0000 0111 1111

    把它和80对比一下:

    0000 0000 0000 0000 0000 0000 0101 0000 //80
    0000 0000 0000 0000 0000 0000 0111 1111 //127

    可以发现,我们只要把80从最高位起每一位全置为1,就可以得到离它最近且比它大的 2n-1,最后再执行一次+1操作即可。具体操作步骤为(为了演示,这里使用了很大的数字):
    原值:

    0011 0000 0000 0000 0000 0000 0000 0010

    1. 无符号右移1位

    0001 1000 0000 0000 0000 0000 0000 0001

    1. 与原值|操作:

    0011 1000 0000 0000 0000 0000 0000 0011

    可以看到最高2位都是1了,也仅能保证前两位为1,这时就可以直接移动两位

    1. 无符号右移2位

    0000 1110 0000 0000 0000 0000 0000 0000

    1. 与原值|操作:

    0011 1110 0000 0000 0000 0000 0000 0011

    此时就可以保证前4位为1了,下一步移动4位

    1. 无符号右移4位

    0000 0011 1110 0000 0000 0000 0000 0000

    1. 与原值|操作:

    0011 1111 1110 0000 0000 0000 0000 0011

    此时就可以保证前8位为1了,下一步移动8位

    1. 无符号右移8位

    0000 0000 0011 1111 1110 0000 0000 0000

    1. 与原值|操作:

    0011 1111 1111 1111 1110 0000 0000 0011

    此时前16位都是1,只需要再移位操作一次,即可把32位都置为1了。

    1. 无符号右移16位

    0000 0000 0000 0000 0011 1111 1111 1111

    1. 与原值|操作:

    0011 1111 1111 1111 1111 1111 1111 1111

    1. 进行+1操作:

    0100 0000 0000 0000 0000 0000 0000 0000

    如此经过11步操作后,我们终于找到了合适的2次幂。写成代码就是:

        initialCapacity |= (initialCapacity >>>  1);
        initialCapacity |= (initialCapacity >>>  2);
        initialCapacity |= (initialCapacity >>>  4);
        initialCapacity |= (initialCapacity >>>  8);
        initialCapacity |= (initialCapacity >>> 16);
        initialCapacity++;
    

    不过为了防止溢出,导致出现负值(如果把符号位置为1,就为负值了)还需要一次校验:

    if (initialCapacity < 0)   // Too many elements, must back off
         initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements

    这样我们就明白了计算最小二次幂数值的原理。

    3.使用指定的初始化容量initial capacity 和加载因子load factor构造一个空HashMap
    /**
    * Constructs an empty <tt>HashMap</tt> with the specified initial
    * capacity and load factor.
    *
    * @param initialCapacity the initial capacity
    * @param loadFactor the load factor
    * @throws IllegalArgumentException if the initial capacity is negative
    * or the load factor is nonpositive
    */
    public HashMap(int initialCapacity, float loadFactor) {
    //如果初始容量小于0,报错
    if (initialCapacity < 0)
    throw new IllegalArgumentException("Illegal initial capacity: " +
    initialCapacity);
    //大于最大容量,直接等于最大容量
    if (initialCapacity > MAXIMUM_CAPACITY)
    initialCapacity = MAXIMUM_CAPACITY;
    //加载因子小于等于0或则加载因子不是数字抛错(isNaN 实际上就是 Not a Number的简称。0.0f/0.0f的值就是NaN,从数学角度说,0/0就是一种未确定)
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
    throw new IllegalArgumentException("Illegal load factor: " +
    loadFactor);
    this.loadFactor = loadFactor;
    //阈值 等于 initialCapacity最小的二次幂数值。
    this.threshold = tableSizeFor(initialCapacity);
    }

    分析:同上面调用this方法。


    4.构造方法传入一个map初始化
    /**
    * Constructs a new <tt>HashMap</tt> with the same mappings as the
    * specified <tt>Map</tt>. The <tt>HashMap</tt> is created with
    * default load factor (0.75) and an initial capacity sufficient to
    * hold the mappings in the specified <tt>Map</tt>.
    *
    * @param m the map whose mappings are to be placed in this map
    * @throws NullPointerException if the specified map is null
    */
    public HashMap(Map<? extends K, ? extends V> m) {
    //加载因子等于默认的0.75f
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    //传入map调用putMapEntries方法
    putMapEntries(m, false);
    }
    分析:加载因子等于默认的0.75f,然后调用putMapEntries()方法

    /**
    * Implements Map.putAll and Map constructor
    *
    * @param m the map
    * @param evict false when initially constructing this map, else
    * true (relayed to method afterNodeInsertion).
    * 判断当前传入的Map长度大于阈值threshold,则HashMap调用resize()方法先扩容
    * 遍历传入的Map将值添加到HashMap里
    */
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    //map长度s
    int s = m.size();
    if (s > 0) {
    //table是一个node节点数组(Node<K,V>[] table)
    if (table == null) { // pre-size
    //map长度s先转为float 然后 除以 加载因子0.75f, 最后加上1.0F得到ft
    float ft = ((float)s / loadFactor) + 1.0F;
    //如果ft小于最大容量为1<<30则t等于ft,否则t等于最大容量为1<<30即2的30次方
    int t = ((ft < (float)MAXIMUM_CAPACITY) ?
    (int)ft : MAXIMUM_CAPACITY);
    //如果t大于阈值threshold
    if (t > threshold)
    //阈值等于满足大于等于t的最小的二次幂数值
    threshold = tableSizeFor(t);
    }
    //如果map长度s大于阈值threshold,需要扩容
    else if (s > threshold)
    resize();
    //遍历传入的map,将值添加到HashMap
    for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
    K key = e.getKey();
    V value = e.getValue();
    putVal(hash(key), key, value, false, evict);
    }
    }
    }
    分析:如果传入的map长度大于0,那么进行如下逻辑判断:
    1.当前节点数组为null,计算阈值大小
    2.如果table不等于Null,map长度s大于阈值threshold,调用resize()扩容
    3.遍历传入的map,将值添加到HashMap
    到这里,我们其实知道以构造方法传入一个map初始化方式,在调用putMapEntries时,table=null,计算完阈值后,不会调用resize()扩容,而是进行遍历然后putVal()操作,相关容量初始化操作,我猜测应该是在putVal()方法里进行,不着急,我们往下会继续分析。


    五:主要方法
    1.hash(Object key)  哈希算法
    在JDK1.8的实现中,优化了高位运算的算法,通过hashCode()的高16位异或低16位实现的:(h = k.hashCode()) ^ (h >>> 16),主要是从速度、功效、质量来考虑的。以下方法得到的int的hash值,
    static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    分析:参考如下知乎评论https://www.zhihu.com/question/20733617
    大家都知道上面代码里的key.hashCode()函数调用的是key键值类型自带的哈希函数,返回int型散列值。
    理论上散列值是一个int型,如果直接拿散列值作为下标访问HashMap主数组的话,考虑到2进制32位带符号的int表值范围从-21474836482147483648。前后加起来大概40亿的映射空间。只要哈希函数映射得比较均匀松散,一般应用是很难出现碰撞的。
    但问题是一个40亿长度的数组,内存是放不下的。你想,HashMap扩容之前的数组初始大小才16。所以这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算(也就是HashMap的长度),得到的余数才能用来访问数组下标。源码中模运算是在这个indexFor( )函数里完成的。
    bucketIndex = indexFor(hash, table.length);
    indexFor的代码也很简单,就是把散列值和数组长度做一个"与"操作,
    static int indexFor(int h, int length) {
       return h & (length-1);
    }

    顺便说一下,这也正好解释了为什么HashMap的数组长度要取2的整次幂。因为这样(数组长度-1)正好相当于一个“低位掩码”。“与”操作的结果就是散列值的高位全部归零,只保留低位值,用来做数组下标访问。以初始长度16为例,16-1=15。2进制表示是00000000 00000000 00001111。和某散列值做“与”操作如下,结果就是截取了最低的四位值。这里的某散列值就是随机的一个数如下的10100101 11000100 00100101。
    但这时候问题就来了,这样就算我的散列值分布再松散,要是只取最后几位的话,碰撞也会很严
    重。更要命的是如果散列本身做得不好,分布上成等差数列的漏洞,恰好使最后几个低位呈现规律性重复,就无比蛋疼。
    这时候“扰动函数”的价值就体现出来了,说到这里大家应该猜出来了。看下面这个图
    preview
    ps:
         1.调用hashCode()得到随机的散列值1111 1111 1111 1111 1111 0000 1110 1010
         2.无符号右移16位 0000 0000 0000 0000 1111 1111 1111 1111
         3.h ^ (h >>> 16) 高16位与低16位异或   (ps: ^ 异或运算)
         为什么做异或运算?
         设想一下,如果n很小,假设为16的话,那么n-1即为15(0000 0000 0000 0000 0000 0000 0000 1111),这样的值如果跟hashCode()直接做与操作,实际上只使用了哈希值的后4位。如果当哈希值的高位变化很大,低位变化很小,这样很容易造成碰撞,所以把高低位都参与到计算中,从而解决了这个问题,而且也不会有太大的开销。

         其实到此我们就得到hash值(散列值),也就是hash(Object key)函数功能,但是我们以后如果需要根据hash值来获取HashMap值所在的下表,还需要将hash值与(HashMap长度 - 1)进行与运算(ps: &" 与"运算,两者都为1才得1,"&"这是是什么运算?)
        (n - 1)& hash    

    右位移16位,正好是32bit的一半,自己的高半区和低半区做异或,就是为了混合原始哈希码的高位和低位,以此来增加大低位的随机性。而且混合后的低位掺杂了高位的部分特征,这样高位的信息也被变相保留下来。
    最后我们来看一下Peter Lawley的一篇专栏文章  《An introduction to optimising a hashing strategy》里的一个实验:他随机选取了352个字符串,在他们散列值完全没有冲突的前提下,对它们做低位掩码,取数组下标。
    preview
    结果显示,当HashMap数组长度为512的时候,也就是用掩码取低9位的时候,在没有扰动函数的
    情况下,发生了103次碰撞,接近30%。而在使用了扰动函数之后只有92次碰撞。碰撞减少了将近
    10%。看来扰动函数确实还是有功效的。

    得到这个hash值我们可以再通过h & (table.length -1)来得到该对象在数据中保存的位置。



    2.get(Object key) 返回指定key值的映射,如果value为null,则返回null!!
    public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
    分析:从源码中我们可以知道,get()方法先调用hash(key)得到哈希值,然后调用getNode()方法

    /**
    * Implements Map.get and related methods
    *
    * @param hash hash for key
    * @param key the key
    * @return the node, or null if none
    *
    * tab[(n - 1) & hash可以理解为桶节点,也就是数组中的节点
    */
    final Node<K,V> getNode(int hash, Object key) {
    //定义一些临时变量,first等于桶节点
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    //如果HashMap不为null且长度大于0且桶节点不为null
    if ((tab = table) != null && (n = tab.length) > 0 &&
    (first = tab[(n - 1) & hash]) != null) {
    //如果桶节点hash值等于传入的哈希值和key值等于传入的key值。。。
    if (first.hash == hash && // always check first node
    ((k = first.key) == key || (key != null && key.equals(k))))
    //返回桶节点
    return first;
    //如果桶位置节点没匹配上且下一个节点不为null
    if ((e = first.next) != null) {
    //如果当前的桶采用红黑树,则调用红黑树的get方法去获取节点
    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;
    }
    分析:根据tab[(n - 1) & hash]取到桶节点,判断是否匹配,匹配则返回该节点值,否则返回null。

    到这里借用下别人的get方法总结:http://cmsblogs.com/?p=3959

    从源码中可以看到,get(E e)可以分为三个步骤:

    1. 通过hash(Object key)方法计算key的哈希值hash。
    2. 通过getNode( int hash, Object key)方法获取node。
    3. 如果node为null,返回null,否则返回node.value。

    hash方法又可分为三步:

    1. 取key的hashCode第二步
    2. key的hashCode高16位异或低16位
    3. 将第一步和第二部得到的结果进行取模运算。

    getNode方法又可分为以下几个步骤:

    1. 如果哈希表为空,或key对应的桶为空,返回null
    2. 如果桶中的第一个节点就和指定参数hash和key匹配上了,返回这个节点。
    3. 如果桶中的第一个节点没有匹配上,而且有后续节点
      1. 如果当前的桶采用红黑树,则调用红黑树的get方法去获取节点
      2. 如果当前的桶不采用红黑树,即桶中节点结构为链式结构,遍历链表,直到key匹配
    4. 找到节点返回null,否则返回null。



    3.resize()  扩容
    final Node<K,V>[] resize() {
    //oldTab旧的Node节点数组
    Node<K,V>[] oldTab = table;
    //旧节点数组长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //旧的阈值
    int oldThr = threshold;
    //新的数组长度newCap(也就是容量),新的阈值newThr
    int newCap, newThr = 0;
    //如果旧节点数组长度大于0
    if (oldCap > 0) {
    //如果旧节点数组长度大于最大容量为1<<30,则阈值等于int最大值,并直接返回旧节点数组 Node<K,V>[] oldTab
    if (oldCap >= MAXIMUM_CAPACITY) {
    //阈值等于int最大值
    threshold = Integer.MAX_VALUE;
    return oldTab;
    }
    //让新容量等于旧容量的两倍值,新容量小于最大容量为1<<30,并且旧容量大于等于默认的初始化容量16
    else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
    oldCap >= DEFAULT_INITIAL_CAPACITY)
    //新的阈值变为旧的阈值两倍
    newThr = oldThr << 1; // double threshold
    }
    //如果旧容量(数组长度)<=0,并且旧的阈值大于0
    else if (oldThr > 0) // initial capacity was placed in threshold
    //新的数组长度等于旧阈值大小
    newCap = oldThr;
    else { // zero initial threshold signifies using defaults
    //如果旧容量<=0,旧阈值<=0
    // 那么新数组长度等于默认的初始化容量16
    newCap = DEFAULT_INITIAL_CAPACITY;
    //新阈值等于 0.75f * 16
    newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }

    //如果新的阈值等于0
    if (newThr == 0) {
    //ft等于 新容量 * 初始化容量16
    float ft = (float)newCap * loadFactor;
    //如果新容量newCap小于最大容量为1<<30并且ft小于最大容量为1<<30,那么新阈值等于ft,否则等于int最大值
    newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
    (int)ft : Integer.MAX_VALUE);
    }
    //阈值等于新的阈值newThr大小
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    //new一个新的Node节点数组,长度等于新容量newCap
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    //直接等于最新的节点数组
    table = newTab;
    //如果旧table不为空,将旧table中的元素复制到新的table
    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()会对HashMap进行扩容,并且重新计算初阈值(阈值:可以理解为当HashMap的长度达到阈值,就需要扩容),大致步骤如下:
                1.判断旧节点数组长度是否大于0,如果大于0,节点数组长度(ps:也就是HashMap容量)和阈值翻倍。
                2.如果旧节点数组长度小于等于0,并且旧阈值大于0,那么新节点数组长度等于旧阈值(注意这里是HashMap容量等于阈值!)。
                3.如果旧节点数组长度小于等于0且阈值小于等于0,初始化,节点数组长度为16,阈值为0.75f * 16。
                4.如果旧数组长度小于等于0并且阈值大于0,那么新阈值等于重新计算后的ft值
                5.旧阈值等于新阈值newThr
                6.旧节点数组等于新节点数组newTab
                7.如果旧节点数组有值,将元素赋值到新的节点数组newTab中


    4.put(k key, V value)  添加方法,键值对形式
    public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
    }
    分析:先通过key键值调用hash()函数计算哈希值,然后调用putVal()方法,传入哈希值,key, value

    /**
    * Implements Map.put and related methods
    *
    * @param hash hash for key
    * @param key the key
    * @param value the value to put
    * @param onlyIfAbsent if true, don't change existing value
    * @param evict if false, the table is in creation mode.
    * @return previous value, or null if none
    */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
    boolean evict) {
    //定义一些临时变量
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //如果HashMap为null或长度为0,则先调用resize()方法初始化HashMap
    if ((tab = table) == null || (n = tab.length) == 0)
    //先给HashMap进行初始化,变量n等于初始化后的长度
    n = (tab = resize()).length;
    //如果映射的桶节点为null则新建一个节点,令p节点等于桶节点tab[i = (n - 1) & hash]
    if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);
    else {
    //映射的桶节点不为null
    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);
    //链表长度大于临界值8
    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
    //转为红黑树
    treeifyBin(tab, hash);
    break;
    }
    //当前节点e匹配上hash和key
    if (e.hash == hash &&
    ((k = e.key) == key || (key != null && key.equals(k))))
    break;
    //p结点等于e节点
    p = e;
    }
    }
    //如果key映射的节点e不为null
    if (e != null) { // existing mapping for key
    ////记录节点的vlaue
    V oldValue = e.value;
    if (!onlyIfAbsent || oldValue == null)
    ////替换value
    e.value = value;
    //回调
    afterNodeAccess(e);
    //返回旧节点值
    return oldValue;
    }
    }
    //修改次数加1
    ++modCount;
    //如果HashMap长度大于阈值
    if (++size > threshold)
    //则调用resize()方法扩容
    resize();
    //插入后回调
    afterNodeInsertion(evict);
    return null;
    }

    putVal方法可以分为下面的几个步骤(ps: 参考别人的总结 http://cmsblogs.com/?p=3959):

    1. 如果哈希表为空,调用resize()创建一个哈希表。
    2. 如果指定参数hash在表中没有对应的桶,即为没有碰撞,直接将键值对插入到哈希表中即可。
    3. 如果有碰撞,遍历桶,找到key映射的节点
      1. 桶中的第一个节点就匹配了,将桶中的第一个节点记录起来。
      2. 如果桶中的第一个节点没有匹配,且桶中结构为红黑树,则调用红黑树对应的方法插入键值对。
      3. 如果不是红黑树,那么就肯定是链表。遍历链表,如果找到了key映射的节点,就记录这个节点,退出循环。如果没有找到,在链表尾部插入节点。插入后,如果链的长度大于TREEIFY_THRESHOLD这个临界值,则使用treeifyBin方法把链表转为红黑树。
    4. 如果找到了key映射的节点,且节点不为null
      1. 记录节点的vlaue。
      2. 如果参数onlyIfAbsent为false,或者oldValue为null,替换value,否则不替换。
      3. 返回记录下来的节点的value。
    5. 如果没有找到key映射的节点(2、3步中讲了,这种情况会插入到hashMap中),插入节点后size会加1,这时要检查size是否大于临界值threshold,如果大于会使用resize方法进行扩容。


    5.remove(Object key) 根据key删除value
    public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
    null : e.value;
    }
    分析:先调用hash(key)计算哈希值,调用removeNode()移除

    /**
    * Implements Map.remove and related methods
    *
    * @param hash hash for key
    * @param key the key
    * @param value the value to match if matchValue, else ignored
    * @param matchValue if true only remove if value is equal
    * @param movable if false do not move other nodes while removing
    * @return the node, or null if none
    */
    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;
    ////如果HashMap不为null且长度大于0且桶节点不为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;
    //如果桶节点node就是要删除的节点,记录桶节点node = p
    if (p.hash == hash &&
    ((k = p.key) == key || (key != null && key.equals(k))))
    node = p;
    //如果桶节点不是要删除的节点,且下一节点不为Null
    else if ((e = p.next) != null) {
    //桶节点结构是红黑树
    if (p instanceof TreeNode)
    //记录节点node等于调用红黑树获取的节点值
    node = ((TreeNode<K,V>)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不为null且(matchValue为false||node.value和参数value匹配)
    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
    //如果桶内的结构为链表,使用链表删除元素的方式删除node(当前结点引用指向删除节点的下一个节点)
    p.next = node.next;
    //修改次数加1
    ++modCount;
    //HashMap长度减1
    --size;
    //删除节点后需要的操作
    afterNodeRemoval(node);
    //返回节点
    return node;
    }
    }
    return null;
    }
    分析:参考总结步骤
    1. 如果数组table为空或key映射到的桶为空,返回null。
    2. 如果key映射到的桶上第一个node的就是要删除的node,记录下来。
    3. 如果桶内不止一个node,且桶内的结构为红黑树,记录key映射到的node。
    4. 桶内的结构不为红黑树,那么桶内的结构就肯定为链表,遍历链表,找到key映射到的node,记录下来。
    5. 如果被记录下来的node不为null,删除node,size-1被删除。
    6. 返回被删除的node。


    到此:我们就把HashMap源码简单的过了一遍。但是,其中关于红黑树的内容,目前暂时都跳过了,以后开一篇单独分析。


    有疑问,扫我二维码添加微信,欢迎骚扰!
    坚持做一件事,一起学习。







  • 相关阅读:
    LeeCode-Spiral Matrix II
    HDU1281(二分图最大匹配,棋盘建图,找关键点)
    HDU1083(二分图最大匹配vector实现)
    HDU2444(判断是否为二分图,求最大匹配)
    HDU1166(线段树单点更新区间查询)
    HDU1045(二分图经典建模)
    POJ1220(大数进制转换)
    POJ3466(01背包变形)
    POJ3180(有向图强连通分量结点数>=2的个数)
    POJ1236 (强连通分量缩点求入度为0和出度为0的分量个数)
  • 原文地址:https://www.cnblogs.com/lizb0907/p/10408883.html
Copyright © 2020-2023  润新知