HashMap(三)之源码分析

通过分析HashMap来学习源码，那么通过此过程我们要带着这几个问题去一起探索

为什么要学习源码
怎么去学习

0.1 为什么要学习源码

这个问题，直接给出结论，学习源码肯定是有好处的，比如:

学习优秀的编码设计
学习一些有用的算法
学习一些简单而又实用的方法
装逼神器，面试加分

0.2 怎么去学习

这个问题，则仁者见仁智者见智，我这里分享下我的学习心得。并通过HashMap的源码解析来实践检测我的学习方法。

先看此代码的实际使用场景
主句分析
遇到难点的地方，先记下啦，不要影响整体节奏
笔记学到的知识点:设计模式、编码风格、算法、有用的方法。

1. 开始分析

要分析源码就要知道，hashmap是怎么定义的，干什么的，
虽然平时都知道new，put,get,remove.那么我们是否曾停下来，看看官方文档，系统的了解它。
这也是中国程序员的通病，严重偏科，理论考试不过关，那在面试官眼里就是基础差！ -- 通过一张图来了解下
从上图我们可以看到，HashMap由链表+数组组成，他的底层结构是一个数组，而数组的元素是一个单向链表。图中是一个长度为16位的数组，每个数组储存的元素代表的是每一个链表的头结点。
上面我们说了有关Hash算法的事情，通过Key进行Hash的计算，就可以获取Key对应的HashCode。好的Hash算法可以计算出几乎出独一无二的HashCode，如果出现了重复的hashCode，就称作碰撞，就算是MD5这样优秀的算法也会发生碰撞，即两个不同的key也有可能生成相同的MD5。
正常情况下，我们通过hash算法，往HashMap的数组中插入元素。如果发生了碰撞事件，那么意味这数组的一个位置要插入两个或者多个元素，这个时候数组上面挂的链表起作用了，链表会将数组某个节点上多出的元素按照尾插法(jdk1.7及以前为头差法)的方式添加。

在补充一下，就开始源码分析吧

HashMap HashMap采用的是数组+链表+红黑树的形式。，它存储的内容是键值对(key-value)映射。
HashMap 继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。
HashMap 的实现不是同步的，这意味着它不是线程安全的。它的key、value都可以为null。此外，HashMap中的映射不是有序的

废话说了这么多，先上一段代码

    // 1.创建hashmap

    Map<String,String> stringMap = new HashMap<>();

    //2. 插入值

    stringMap.put("key1","vaule1");

    // 3. 获取值

    String value= stringMap.get("key1");

    // 4. 删除key-value

    stringMap.remove("key1");

以上就是我们使用HashMap的常用代码，我们就围绕此段的代码来分析。顺便稍后整理下，我们能学到啥

此分析基于JDK1.8
需要了解位运算

1.0几个重要的变量

initialCapacity 初始化容量16
loadFactor 负载因子默认0.75

这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作

threshold 阈值，用于判断是否需要调整HashMap的容量，怎么获得阈值，
1.7 中 threshold = size*loadFactor
看一下下面这段代码,这个值的计算算法得到了进一步改进

    // 返回的是一个size为 2的n次方的值

    // 这是 jdk1.8 中的优化获取阈值

    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;

    }

问题来了，为啥tableSizeFor要得到一个2的n次方

综上 hashmap 有12个成员变量，看详细源码，有分类分析

//默认初始容量为16，这里这个数组的容量必须为2的n次幂。

    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    //最大容量为2的30次方

    static final int MAXIMUM_CAPACITY = 1 << 30;

    //默认加载因子

    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    //以Node<K,V>为元素的数组，也就是上图HashMap的纵向的长链数组，起长度必须为2的n次幂

    transient Node<K,V>[] table;

    //已经储存的Node<key,value>的数量，包括数组中的和链表中的

    transient int size;

    //扩容的临界值，或者所能容纳的key-value对的极限。当size>threshold的时候就会扩容

    int threshold;

    //加载因子

    final float loadFactor;

1.1 创建HashMap

我们看源码，HashMap提供了4个构造方法

public 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);

    }

    public HashMap(int initialCapacity) {

        this(initialCapacity, DEFAULT_LOAD_FACTOR);

    }

    public HashMap() {

        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted

    }

    public HashMap(Map<? extends K, ? extends V> m) {

        this.loadFactor = DEFAULT_LOAD_FACTOR;

        putMapEntries(m, false);

    }

这里我们有没有发现，构造方法并没有new 出一个table来作为一个hashMap，而在jdk1.7是这样的。

//在jdk1.7中，当HashMap创建的时候，table这个数组确实会初始化；但是到了jdk1.8中则没有

public HashMap(int initialCapacity, float loadFactor) {

    ......

    this.loadFactor = loadFactor;

    threshold = (int)(capacity * loadFactor);

    table = new Entry[capacity];        //注意这里初始化了

    init();

}

JDK1.8 中真正table初始化的地方是在putVal()方法中，即首次向HashMap添加元素时，调用resize()创建并初始化了一个table数组
那么接下来分析一下看putVal()方法

1.2 HashMap插入值

put()-->>putVal() 实际上是下面这个方法的调用，来分析一下此方法

详见代码分析
如上图，此段代码核心分5个关键地方

1.2.0 第一个箭头的地方

就是上面说的，jdk1.8 初始化table的地方

table为空，则调用resize()函数创建一个
调用resize()创建并初始化了一个table数组。
区别与1.7 的初始化table,这里类似于一种懒加载的思想，可以借鉴下

1.2.1

如果该index位置的Node元素不存在，则直接创建一个新的Node

这里创建新的node,首先需要知道hash 怎么来的

//首先将得到key对应的哈希值：h = key.hashCode()，然后通过hashCode()的高16位异或低16位实现的

//主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。

static final int hash(Object key) {

        int h;

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

    }

- 为什么要先高16位异或低16位再取模运算？
接着分析怎么获取这个tab当前的index = (n - 1) & hash，n是新创建的table数组的长度,取模运算.得到这个node保存的位置。
HashMap底层数组的长度总是2的n次方，这是HashMap在速度上的优化。当length总是2的n次方时，hash&(length-1) 运算等价于对length取模，也就是hash % length，但是&比%具有更高的效率。

1.2.2

如果该index位置的Node元素是TreeNode类型即红黑树类型了，则直接按照红黑树的插入方式进行插入

1.2.3

如果该index位置的Node元素是非TreeNode类型则，则按照链表的形式进行插入操作

这个要添加的位置上面已经有元素了，也就是发生了碰撞。这个时候就要具体情况分
1.key值相同，直接覆盖
2.链表已经超过了8位，变成了红黑树
3.链表是正常的链表

1.2.4

链表插入操作完成后，判断是否超过阈值TREEIFY_THRESHOLD（默认是8），超过则要么数组扩容要么链表转化成红黑树

这里分析一下扩容这个方法

 final Node<K,V>[] resize() {

        Node<K,V>[] oldTab = table;         //创建一个oldTab数组用于保存之前的数组

        int oldCap = (oldTab == null) ? 0 : oldTab.length;  //获取原来数组的长度

        int oldThr = threshold;             //原来数组扩容的临界值

        int newCap, newThr = 0;

        if (oldCap > 0) {

            if (oldCap >= MAXIMUM_CAPACITY) {   //如果原来的数组长度大于最大值(2^30)

                threshold = Integer.MAX_VALUE;  //扩容临界值提高到正无穷

                return oldTab;                  //返回原来的数组，也就是系统已经管不了了，随便你怎么玩吧

            }

            //else if((新数组newCap)长度乘2) < 最大值(2^30) && (原来的数组长度)>= 初始长度(2^4))

            //这个else if 中实际上就是咋判断新数组(此时刚创建还为空)和老数组的长度合法性，同时交代了，

            //我们扩容是以2^1为单位扩容的。下面的newThr(新数组的扩容临界值)一样，在原有临界值的基础上扩2^1

            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&

                     oldCap >= DEFAULT_INITIAL_CAPACITY)

                newThr = oldThr << 1; // double threshold

        }

        else if (oldThr > 0)

            newCap = oldThr;    //新数组的初始容量设置为老数组扩容的临界值

        else {               // 否则 oldThr == 0,零初始阈值表示使用默认值

            newCap = DEFAULT_INITIAL_CAPACITY;  //新数组初始容量设置为默认值

            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);     //计算默认容量下的阈值

        }

        if (newThr == 0) {  //如果newThr == 0，说明为上面 else if (oldThr > 0)

        //的情况(其他两种情况都对newThr的值做了改变),此时newCap = oldThr;

            float ft = (float)newCap * loadFactor;  //ft为临时变量，用于判断阈值的合法性

            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?

                      (int)ft : Integer.MAX_VALUE);     //计算新的阈值

        }

        threshold = newThr; //改变threshold值为新的阈值

        @SuppressWarnings({"rawtypes","unchecked"})

            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];

        table = newTab; //改变table全局变量为，扩容后的newTable

        if (oldTab != null) {

            for (int j = 0; j < oldCap; ++j) {  //遍历数组，将老数组(或者原来的桶)迁移到新的数组(新的桶)中

                Node<K,V> e;

                if ((e = oldTab[j]) != null) {  //新建一个Node<K,V>类对象，用它来遍历整个数组

                    oldTab[j] = null;

                    if (e.next == null)

                                //将e也就是oldTab[j]放入newTab中e.hash & (newCap - 1)的位置，

                        newTab[e.hash & (newCap - 1)] = e;  //这个我们之前讲过，是一个取模操作

                    else if (e instanceof TreeNode)     //如果e已经是一个红黑树的元素，这个我们不展开讲

                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

                    else { // 链表重排，这一段是最难理解的，也是ldk1.8做的一系列优化，我们在下面详细讲解

                        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) { //关键判断条件,即可将原桶中的数据分成2类

                                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);

                        //可以知道，如果(e.hash & oldCap) == 0，则  newTab[j] = loHead = e = oldTab[j]，即索引位置没变。反之 (e.hash & oldCap) != 0, newTab[j + oldCap] = hiHead = e = oldTab[j],也就是说，此时把原数组[j]位置上的桶移到了新数组[j+原数组长度]的位置上了

。

                        if (loTail != null) {

                            loTail.next = null;

                            newTab[j] = loHead;

                        }

                        if (hiTail != null) {

                            hiTail.next = null;

                            newTab[j + oldCap] = hiHead;

                        }

                    }

                }

            }

        }

        return newTab;

    }

扩容涉及到数组迁移问题
按照2倍扩容的方式，那么就需要将之前的所有元素全部重新按照2倍桶的长度重新计算所在桶。这里为啥是2倍？也涉及到reHash
先，要生成一个新的桶数组，然后要把所有元素都重新Hash落桶一次，几乎等于重新执行了一次所有元素的put。

因为2倍的话，更加容易计算他们所在的桶，并且各自不会相互干扰。如原桶长度是4，现在桶长度是8，那么

桶0中的元素会被分到桶0和桶4中

桶1中的元素会被分到桶1和桶5中

桶2中的元素会被分到桶2和桶6中

桶3中的元素会被分到桶3和桶7中

为啥是这样呢？

桶0中的元素的hash值后2位必然是00，这些hash值可以根据后3位000或者100分成2类数据。他们分别&（8-1）即&111,则后3位为000的在桶0中，后3位为100的必然在桶4中。其他同理，也就是说桶4和桶0重新瓜分了原来桶0中的元素。

如果换成其他倍数，那么瓜分就比较混乱了。

这样在瓜分这些数据的时候，只需要先把这些数据分类，如上述桶0中分成000和100 2类，然后直接构成新的链表，分类完毕后，直接将新的链表挂在对应的桶下即可

代码中注释的很详细了，此处分析可以参考下面提供的而参考文章，分析需要依赖于位运算

1.3 HashMap获取值

直接上代码

 public V get(Object key) {

 // 这里可以看到 get方法其实是拿到一个Node对象后，再取其value

        Node<K,V> e;

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

    }

所以核心方法应该是 getNode()

1.4 HashMap删除key-value