容器源码阅读(一)-HashMap 从理论数据结构到源码解读（全）

目录

一 HashMap 简介

二 HashMap版本变化

三 底层数据结构分析(理论分析)

3.2 JDK1.8之后

四 源码分析

4.1 基本属性

4.2 构造方法

4.3 存取put()方法

4.4 扩容 resize（） 方法

4.5 get(Object key)方法

参考:

 

---

一 HashMap 简介

。HashMap采用key/value存储结构，每个key对应唯一的value，查询和修改的速度都很快，能达到O(1)的平均时间复杂度。它是非线程安全的，且不保证元素存储的顺序，它基于哈希表的Map接口实现，是常用的Java集合之一。它非常常用与好用，学了这么久的java，源码不透彻分析，也不好意思说学过java，它内部是怎么实现的，又能跟我们带来什么技术上的细节启发呢，你难道不好奇吗？

二 HashMap版本变化

JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树），以减少搜索时间，具体可以参考 treeifyBin方法。

三 底层数据结构分析(理论分析)

3.1 JDK1.8之前

JDK1.8 之前 HashMap 底层是 数组和链表 结合在一起使用也就是 链表散列。HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 (n - 1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。

所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 简而言之使用扰动函数之后可以减少hash碰撞，也就是hash的key重复

Java的HashMap实现的数据结构是一个哈希表，其解决哈希冲突的方法是拉链法，使用的哈希函数是取模法。与常规的直接取模法不同，HashMap是通过位运算来实现取模的。这部分思想与ArrayDeque的实现原理是类似的。 

JDK 1.8 HashMap 的 hash 方法源码:

JDK 1.8 的 hash方法 相比于 JDK 1.7 hash 方法更加简化，但是原理不变。

    static final int hash(Object key) {

      int h;

      // key.hashCode()：返回散列值也就是hashcode

      // ^ ：按位异或

      // >>>:无符号右移，忽略符号位，空位都以0补齐

      return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

  }

对比一下 JDK1.7的 HashMap 的 hash 方法源码.

static int hash(int h) {

    // This function ensures that hashCodes that differ only by

    // constant multiples at each bit position have a bounded

    // number of collisions (approximately 8 at default load factor).

 

    h ^= (h >>> 20) ^ (h >>> 12);

    return h ^ (h >>> 7) ^ (h >>> 4);

}

所谓 “拉链法” 就是：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。

使用的哈希函数是取模法。与常规的直接取模法不同，HashMap是通过位运算来实现取模的。这部分思想与ArrayDeque的实现原理是类似的。 

3.2 JDK1.8之后

相比于之前的版本，jdk1.8在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。

数组的查询效率为O(1)，链表的查询效率是O(k)，红黑树的查询效率是O(log k)，k为桶中的元素个数，所以当元素数量非常多的时候，转化为红黑树能极大地提高效率。

 

四 源码分析

4.1 基本属性

/**

 * 默认初始容量-必须是2的幂。默认是16

 */

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;



/**

 *如果隐式指定了更高的值，则使用的最大容量

 *由任何一个带参数的构造函数。

 *必须是2的幂<=1<<30。 2的30次方

 */

static final int MAXIMUM_CAPACITY = 1 << 30;



/**

 * 构造函数中未指定时使用的加载因子。默认是0.75

 */

static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**

 *  当桶(bucket)上的结点数大于这个值时会转成红黑树

 */

static final int TREEIFY_THRESHOLD = 8;

/**

 * 当桶(bucket)上的结点数小于这个值时树转链表

 */

static final int UNTREEIFY_THRESHOLD = 6;

/**

 * 桶中结构转化为红黑树对应的table的最小大小

 */

static final int MIN_TREEIFY_CAPACITY = 64;

/**

 * 哈希表的加载因子。

 *

 * @serial

 */

final float loadFactor;

/**

 * 也就是存储值的Node节点

 * 数组，又叫作桶（bucket）

 *分配时，长度总是2的幂。

 */

transient MyHashMap.Node[] table;

/**

  作为entrySet()的缓存.

 * 遍历我们的key与Value的时候使用

 */

transient Set> entrySet;

/**

 * 元素的数量

 */

transient int size;

/**

 * 修改次数，用于在迭代的时候执行快速失败策略

 */

transient int modCount;

/**

 * 当桶的使用数量达到多少时进行扩容，threshold = capacity * loadFactor

 */

int threshold;

(1）容量

容量为数组的长度，亦即桶的个数，默认为16，最大为2的30次方，当容量达到64时才可以树化。

（2）loadFactor装载因子

装载因子用来计算容量达到多少时才进行扩容，默认装载因子为0.75。

loadFactor加载因子是控制数组存放数据的疏密程度，loadFactor越趋近于1，那么 数组中存放的数据(entry)也就越多，也就越密，也就是会让链表的长度增加，loadFactor越小，也就是趋近于0，数组中存放的数据(entry)也就越少，也就越稀疏。

loadFactor太大导致查找元素效率低，太小导致数组的利用率低，存放的数据会很分散。loadFactor的默认值为0.75f是官方给出的一个比较好的临界值。

给定的默认容量为 16，负载因子为 0.75。Map 在使用过程中不断的往里面存放数据，当数量达到了 16 * 0.75 = 12 就需要将当前 16 的容量进行扩容，而扩容这个过程涉及到 rehash、复制数据等操作，所以非常消耗性能。

（3）树化

树化，当容量达到64且链表的长度达到8时进行树化，当链表的长度小于6时反树化。

（4）threshold

threshold = capacity * loadFactor，当Size>=threshold的时候，那么就要考虑对数组的扩增了，也就是说，这个的意思就是 衡量数组是否需要扩增的一个标准。

 

1 Node内部类

Node是一个典型的单链表节点，其中，hash用来存储key计算得来的hash值。

static class Node implements Map.Entry {

    final int hash;

    final K key;

    V value;

    Node next;

}

复制代码

2 TreeNode内部类

红黑树节点类，它继承自LinkedHashMap中的Entry类

TreeNode是一个典型的树型节点，其中，prev是链表中的节点，用于在删除元素的时候可以快速找到它的前置节点。

// 位于HashMap中

。

static final class TreeNode extends LinkedHashMap.Entry {
        TreeNode parent;  // 父
        TreeNode left;    // 左
        TreeNode right;   // 右
        TreeNode prev;    // needed to unlink next upon deletion
        boolean red;           // 判断颜色
        TreeNode(int hash, K key, V val, Node next) {
            super(hash, key, val, next);
        }
        // 返回根节点
        final TreeNode root() {
            for (TreeNode r = this, p;;) {
                if ((p = r.parent) == null)
                    return r;
                r = p;

       }

4.2 构造方法

HashMap 中有四个构造方法，它们分别如下：这里没有什么特别要注意和好说的 看一下即可

static final class TreeNode extends LinkedHashMap.Entry {
        TreeNode parent;  // 父
        TreeNode left;    // 左
        TreeNode right;   // 右
        TreeNode prev;    // needed to unlink next upon deletion
        boolean red;           // 判断颜色
        TreeNode(int hash, K key, V val, Node next) {
            super(hash, key, val, next);
        }
        // 返回根节点
        final TreeNode root() {
            for (TreeNode r = this, p;;) {
                if ((p = r.parent) == null)
                    return r;
                r = p;

       }

putMapEntries方法：

final void putMapEntries(MapK, ? extends V> m, boolean evict) {

    int s = m.size();

    if (s > 0) {

        // 判断table是否已经初始化

        if (table == null) { // pre-size

            // 未初始化，s为m的实际元素个数

            float ft = ((float)s / loadFactor) + 1.0F;

            int t = ((ft < (float)MAXIMUM_CAPACITY) ?

                    (int)ft : MAXIMUM_CAPACITY);

            // 计算得到的t大于阈值，则初始化阈值

            if (t > threshold)

                threshold = tableSizeFor(t);

        }

        // 已初始化，并且m元素个数大于阈值，进行扩容处理

        else if (s > threshold)

            resize();

        // 将m中的所有元素添加至HashMap中

        for (Map.EntryK, ? extends V> e : m.entrySet()) {

            K key = e.getKey();

            V value = e.getValue();

            putVal(hash(key), key, value, false, evict);

        }

    }

}

实际关键就这一步 进行Map的遍历转换成Hashmap

   for (Map.EntryK, ? extends V> e : m.entrySet()) {

            K key = e.getKey();

            V value = e.getValue();

            putVal(hash(key), key, value, false, evict);

        }

 

4.3 存取put()方法

 

/**
 * Associates the specified value with the specified key in this map.
 * If the map previously contained a mapping for the key, the old
 * value is replaced.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with key, or
 *         null if there was no mapping for key.
 *         (A null return can also indicate that the map
 *         previously associated null with key.)
 */
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

如果放入的key已经有值是会被覆盖的，底层都是putValue

onlyIfAbsent是false 如果是true不会覆盖原先的值，默认是false所以put方法是默认覆盖的

evict是true，如果是false是创建模式 这个不是很清楚有什么作用继续往下看

/**

 * 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) {

    //c语言的命名方式

    Node[] tab; Node p; int n, i;

     如果桶的数量为0，则初始化

    if ((tab = table) == null || (n = tab.length) == 0) {

        //如果存放元素为空 resize()?

        n = (tab = resize()).length;

    }

    // (n - 1) & hash 计算元素在哪个桶中

    if ((p = tab[i = (n - 1) & hash]) == null)

        // 初始化放入桶中第一个位置

        tab[i] = newNode(hash, key, value, null);

    else {

        // 如果桶中已经有元素存在了

        Node e; K k;

        // 如果桶中第一个元素的key与待插入元素的key相同，保存到e中用于后续修改value值

        if (p.hash == hash &&

                ((k = p.key) == key || (key != null && key.equals(k))))

            e = p;

        else if (p instanceof TreeNode) {

            //如果节点是树类型 插入树节点

            e = ((TreeNode)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);

                    // -1 for 1st 桶中的数量大于8个时 树化

                    if (binCount >= TREEIFY_THRESHOLD - 1)

                        treeifyBin(tab, hash);

                    break;

                }

                //如果该值和key已经存在 不操作 退出

                if (e.hash == hash &&

                        ((k = e.key) == key || (key != null && key.equals(k))))

                    break;

                p = e;

            }



            // 如果找到了对应key的元素  记录下旧值 判断是否需要替换旧值 并返回旧值

            if (e != null) {

                V oldValue = e.value;

                if (!onlyIfAbsent || oldValue == null) {

                    e.value = value;

                }

                // 在节点被访问后做点什么事，在LinkedHashMap中用到

                afterNodeAccess(e);

                // 返回旧值

                return oldValue;

            }

        }

    }

    //操作次数加一 这个次数记录有什么意义呢

    ++modCount;

    //如果当前容量 大于 16*0.75 = 12 扩容

    if (++size > threshold)

        resize();



    // 在节点插入后做点什么事，在LinkedHashMap中用到

    afterNodeInsertion(evict);



    return null;

}

 

 

所以这个put方法核心的流程逻辑在于，

1 容器与bucket初始化。 容器没有初始化的时候初始化 并查找我们存入的hash值bucket

查找bucket的方法为(n - 1) & hash   取n-1也就是容器大小位数与我们存入key的hash值&运算。

2. 为空直接创建新的节点插入bucket

3. 不为空的bucket 要根据是链表插入还是树形结构进行插入

   这里同时也处理二种特殊情况与临界情况，

• bucket达到了我们设定的8个要进行树化，增加查询效率，
• 存入的值key已经存在，默认是覆盖旧值，返回旧值，
• 临界情况是我们存入元素后，大小刚好为我们容器需要扩容的大小需要进行扩容，

4.4 扩容 resize（） 方法

进行扩容，会伴随着一次重新hash分配，并且会遍历hash表中所有的元素，是非常耗时的。在编写程序中，要尽量避免resize。

final Node[] resize() {
    Node[] 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;
        }
        // 没超过最大值，就扩充为原来的2倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else { 
        // signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 计算新的resize上限
    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[] newTab = (Node[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        // 把每个bucket都移动到新的buckets中
        for (int j = 0; j < oldCap; ++j) {
            Node 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)e).split(this, newTab, j, oldCap);
                else { 
                    Node loHead = null, loTail = null;
                    Node hiHead = null, hiTail = null;
                    Node next;
                    do {
                        next = e.next;
                        // 原索引
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        // 原索引+oldCap
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 原索引放到bucket里
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 原索引+oldCap放到bucket里
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

4.5 get(Object key)方法

public V get(Object key) {

    Node e;

    return (e = getNode(hash(key), key)) == null ? null : e.value;

}



final Node getNode(int hash, Object key) {

    Node[] tab;

    Node first, e;

    int n;

    K k;

    // 如果桶的数量大于0并且待查找的key所在的桶的第一个元素不为空

    if ((tab = table) != null && (n = tab.length) > 0 &&

            (first = tab[(n - 1) & hash]) != null) {

        // 检查第一个元素是不是要查的元素，如果是直接返回

        if (first.hash == hash && // always check first node

                ((k = first.key) == key || (key != null && key.equals(k))))

            return first;

        if ((e = first.next) != null) {

            // 如果第一个元素是树节点，则按树的方式查找

            if (first instanceof TreeNode)

                return ((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;

}

（1）计算key的hash值；

（2）找到key所在的桶及其第一个元素；

（3）如果第一个元素的key等于待查找的key，直接返回；

（4）如果第一个元素是树节点就按树的方式来查找，否则按链表方式查找；

 

参考:

1 https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/HashMap.md

2 https://juejin.im/post/5cb163bee51d456e46603dfe#heading-0 死磕 java集合之HashMap源码分析

3 https://blog.csdn.net/wang7807564/article/details/79636752 Java高级技术第四章——Java容器类Map之快速的HashMap