---

关于HashMap，一直都是一个非常热门的话题，只要你出去面试，一定少不了它！
本文主要结合 JDK1.7 和 JDK1.8 的区别，就HashMap的数据结构和实现功能，进行深入探讨。

HashMap简介

在程序编程的时候，HashMap是一个使用非常频繁的容器类，它允许键值都放入null元素（但是键位置只有一个为null）。

除该类方法未实现同步外，其余跟Hashtable大致相同，但跟TreeMap不同，该容器不保证元素顺序，根据需要该容器可能会对元素重新哈希，元素的顺序也会被重新打散，因此不同时间迭代同一个HashMap的顺序可能会不同。

HashMap容器，实质还是一个哈希数组结构，在元素插入的时候，存在hash冲突的可能性。

解决hash冲突有哪些方式？

1、开放地址方式（当发生hash冲突时，就继续以此继续寻找，直到找到没有冲突的hash值）。

2、拉链方式（将冲突的元素放入链表）， HashMap采用的就是第二种方式，拉链法。

• 在jdk1.7中，HashMap主要是由数组+链表组成，当发生hash冲突的时候，就将冲突的元素放入链表中。
• 从jdk1.8开始，HashMap主要是由数组+链表+红黑树实现的，相比jdk1.7而言，多了一个红黑树实现。

TIP：将链表转换成红黑树前会判断，即使阈值大于8，但是数组长度小于64，此时并不会将链表变成红黑树，而是选择进行数组扩容。
这样做的目的是因为数组比较小，尽量避开红黑树结构，这种情况下变成为红黑树结构，反而会降低效率，因为红黑树需要进行左旋，右旋，变色这些操作来保持平衡。同时数组长度小于64时，搜索时间相对要快些。综上所述为了提高性能和减少搜索时间，底层在阈值大于8并且数组长度大于64时，链表才会转换为红黑树，具体可以参考treeifyBin方法。

final void treeifyBin(Node<K, V>[] tab, int hash) {
    int n, index;
    Node<K, V> e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        // 如果桶数量小于64，直接扩容而不用树化
        // 因为扩容之后，链表会分化成两个链表，达到减少元素的作用
        // 当然也不一定，比如容量为4，里面存的全是除以4余数等于3的元素
        // 这样即使扩容也无法减少链表的长度
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K, V> hd = null, tl = null;
        // 把所有节点换成树节点
        do {
            TreeNode<K, V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        // 如果进入过上面的循环，则从头节点开始树化
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

HashMap有哪些特点？

• 存储无序；
• 键和值位置都可以为null，但是键位置只能一个为null；
• 键位置的唯一的，底层的数据结构控制的；
• 从 jdk1.8 开始，HashMap主要是由数组+链表+红黑树实现的；
• 阈值大于8并且数组长度大于64时，链表才会转换为红黑树。

源码分析

关键参数

• table：一个哈希桶数组，键值对就存放在里面。

• size：表示实际存在的键值对数量。

• modCount：记录修改次数。

• threshold：表示容器所能容纳的key-value对极限。

• loadFactor：负载因子。

    transient Node<K,V>[] table;

    transient int size;

    transient int modCount;

    int threshold;
 
    final float loadFactor;

HashMap是一个用于存储Key-Value键值对的集合，每一个键值对也叫做Node（在Java7叫Entry，在Java8中叫Node）。这些个键值对（Node）分散存储在一个数组当中，这个数组就是HashMap的主干。

每一个节点都会保存自身的hash、key、value以及下个节点。

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

两个参数可以影响HashMap的性能：初始容量（inital capacity）和负载因子（load factor）。

初始容量（inital capacity）：指table的初始长度length（默认值是16）。

负载因子（load factor）：指自动扩容的临界值（默认值是0.75）。

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final float DEFAULT_LOAD_FACTOR = 0.75f;

threshold是HashMap所能容纳的最大数据量的Node(键值对)个数，计算公式threshold = capacity * Load factor。当entry的数量超过capacity*load_factor时，容器将自动扩容并重新哈希，扩容后的HashMap容量是之前容量的两倍，所以数组的长度总是2的n次方。

获取数组下标

不管增加、删除还是查找键值对，定位到数组的位置都是很关键的第一步，打开hashMap的任意一个增加、删除、查找方法，从源码可以看出，通过key获取数组下标，主要做了3步操作，其中length指的是容器数组的大小。

源码部分

/**获取hash值方法*/
static final int hash(Object key) {
     int h;
     // h = key.hashCode() 为第一步 取hashCode值（jdk1.7）
     // h ^ (h >>> 16)  为第二步 高位参与运算（jdk1.7）
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//jdk1.8
}
/**获取数组下标方法*/
static int indexFor(int h, int length) {
	//jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
     return h & (length-1);  //第三步 取模运算
}

put方法

HashMap数组每一个元素的初始值都是Null。

调用put方法会发生什么呢？

比如调用hashMap.put("apple", 0) ，插入一个 Key 为apple的元素。这时候我们需要利用一个哈希函数来确定 Entry 的插入位置（index）：index = Hash（“apple”）

假定最后计算出的index是2，那么结果如下：

但是，因为HashMap的长度是有限的，当插入的 Entry 越来越多时，再完美的 Hash 函数也难免会出现 index 冲突的情况。比如下面这样：

这时候该怎么办呢？我们可以利用链表来解决。

HashMap数组的每一个元素不止是一个Entry对象，也是一个链表的头节点。每一个 Entry 对象通过 Next 指针指向它的下一个Entry节点。

当新来的Entry映射到冲突的数组位置时，只需要插入到对应的链表即可。

• java8 之前是头插法，就是说新来的值会取代原有的值，原有的值就顺推到链表中去，就像上面的例子一样，因为写这个代码的作者认为后来的值被查找的可能性更大一点，提升查找的效率。

• 在 java8 之后，都是所用尾部插入了。

为什么 java8 之后为什么采用尾插法呢？

假如我们现在往一个容量大小为2的 hashMap 中 put 两个值，负载因子是0.75是不是我们在put第二个的时候就会进行resize？ 因为2 * 0.75 = 1 所以插入第二个就要resize了。

现在我们要在容量为2的容器里面用不同线程插入A，B，C，假如我们在resize之前打个断点，那意味着数据都插入了但是还没resize那扩容前可能是这样的。

我们可以看到链表的指向A->B->C

A的下一个指针是指向B的

因为resize的赋值方式，也就是使用了单链表的头插入方式，同一位置上新元素总会被放在链表的头部位置。

在旧数组中同一条Entry链上的元素，通过重新计算索引位置后，有可能被放到了新数组的不同位置上。

就可能出现下面的情况，大家发现问题没有？

B的下一个指针指向了A

一旦几个线程都调整完成，就可能出现环形链表

如果这个时候去取值，悲剧就出现了——Infinite Loop。

因为java8之后链表有红黑树的部分，大家可以看到代码已经多了很多if else的逻辑判断了，红黑树的引入巧妙的将原本 O(n) 的时间复杂度降低到了 O(logn)。

使用头插会改变链表的上的顺序，但是如果使用尾插，在扩容时会保持链表元素原本的顺序，就不会出现链表成环的问题了。

就是说原本是A->B，在扩容后那个链表还是A->B

Java7在多线程操作HashMap时可能引起死循环，原因是扩容转移后前后链表顺序倒置，在转移过程中修改了原来链表中节点的引用关系。

Java8在同样的前提下并不会引起死循环，原因是扩容转移后前后链表顺序不变，保持之前节点的引用关系。

那是不是意味着Java8就可以把HashMap用在多线程中呢？

我认为即使不会出现死循环，但是通过源码看到put/get方法都没有加同步锁，多线程情况最容易出现的就是：无法保证上一秒put的值，下一秒get的时候还是原值，所以线程安全还是无法保证。

resize扩容过程

在说jdk1.8的HashMap动态扩容之前，我们先来了解一下jdk1.7的HashMap扩容实现，因为jdk1.8代码实现比Java1.7复杂了不止一倍，主要是Java1.8引入了红黑树设计，但是实现思想大同小异！

jdk1.7的扩容实现

源码部分

/**
  * JDK1.7扩容方法
  * 传入新的容量
  */
void resize(int newCapacity) {
    //引用扩容前的Entry数组
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
	//扩容前的数组大小如果已经达到最大(2^30)了
    if (oldCapacity == MAXIMUM_CAPACITY) {
		//修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
        threshold = Integer.MAX_VALUE;
        return;
    }
	//初始化一个新的Entry数组
    Entry[] newTable = new Entry[newCapacity];
	//将数据转移到新的Entry数组里，这里包含最重要的重新定位
    transfer(newTable);
	//HashMap的table属性引用新的Entry数组
    table = newTable;
    threshold = (int) (newCapacity * loadFactor);//修改阈值
}

jdk1.7扩容总结： newTable[i]的引用赋给了e.next，也就是使用了单链表的头插入方式，同一位置上新元素总会被放在链表的头部位置；这样先放在一个索引上的元素终会被放到Entry链的尾部(如果发生了hash冲突的话），这一点和Jdk1.8有区别。在旧数组中同一条Entry链上的元素，通过重新计算索引位置后，有可能被放到了新数组的不同位置上。

jdk1.8的扩容实现

源码如下：

final Node<K,V>[] resize() {
	//引用扩容前的node数组
        Node<K,V>[] oldTab = table;
	//旧的容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
	//旧的阈值
        int oldThr = threshold;
	//新的容量、阈值初始化为0
        int newCap, newThr = 0;
        if (oldCap > 0) {
		//如果旧容量已经超过最大容量，让阈值也等于最大容量，以后不再扩容
                threshold = Integer.MAX_VALUE;
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
	    // 没超过最大值，就扩充为原来的2倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
		//如果旧容量翻倍没有超过最大值，且旧容量不小于初始化容量16，则翻倍
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
	    //初始化容量设置为阈值
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
	    //0的时候使用默认值初始化
            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) {
	    //轮询老数组所有数据
            for (int j = 0; j < oldCap; ++j) {
		//以一个新的节点引用当前节点，然后释放原来的节点的引用
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
		    //如果e没有next节点，证明这个节点上没有hash冲突，则直接把e的引用给到新的数组位置上
                    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 {
		        // 链表优化重hash的代码块
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
			//从这条链表上第一个元素开始轮询，如果当前元素新增的bit是0，则放在当前这条链表上，如果是1，则放在"j+oldcap"这个位置上，生成“低位”和“高位”两个链表
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
				 //元素是不断的加到尾部的，不会像1.7里面一样会倒序
                                    loTail.next = e;
				//新增的元素永远是尾元素
                                loTail = e;
                            }
                            else {
				//高位的链表与低位的链表处理逻辑一样，不断的把元素加到链表尾部
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
			//低位链表放到j这个索引的位置上
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
			//高位链表放到(j+oldCap)这个索引的位置上
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
}

get()方法

get(Object key)方法根据指定的key值返回对应的value，getNode(hash(key), key))得到相应的Node对象e，然后返回e.value。因此getNode()是算法的核心。

源码部分：

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

通过hash值和key获取节点Node方法，源码部分：

    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) {
            //1、判断第一个元素是否与key匹配
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                //2、判断链表是否红黑树结构
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                //3、如果不是红黑树结构，直接循环判断
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

在红黑树中找到指定k的TreeNode，源码部分：

/**
  * 这里面情况分很多中，主要是因为考虑了hash相同但是key值不同的情况，查找的最核心还是落在key值上
  */
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
            TreeNode<K,V> p = this;
            do {
                int ph, dir; K pk;
                TreeNode<K,V> pl = p.left, pr = p.right, q;
		//判断要查询元素的hash是否在树的左边
                if ((ph = p.hash) > h)
                    p = pl;
		//判断要查询元素的hash是否在树的右边
                else if (ph < h)
                    p = pr;
		//查询元素的hash与当前树节点hash相同情况
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
                    return p;
		//上面的三步都是正常的在二叉查找树中寻找对象的方法
		//如果hash相等，但是内容却不相等
                else if (pl == null)
                    p = pr;
                else if (pr == null)
                    p = pl;
		//如果可以根据compareTo进行比较的话就根据compareTo进行比较
                else if ((kc != null ||
                          (kc = comparableClassFor(k)) != null) &&
                         (dir = compareComparables(kc, k, pk)) != 0)
                    p = (dir < 0) ? pl : pr;
		//根据compareTo的结果在右孩子上继续查询
                else if ((q = pr.find(h, k, kc)) != null)
                    return q;
		//根据compareTo的结果在左孩子上继续查询
                else
                    p = pl;
            } while (p != null);
            return null;
}

get方法，首先通过hash()函数得到对应数组下标，然后依次判断。

1. 判断第一个元素与key是否匹配，如果匹配就返回参数值；
2. 判断链表是否红黑树，如果是红黑树，就进入红黑树方法获取参数值；
3. 如果不是红黑树结构，直接循环判断，直到获取参数为止；

remove()方法

remove(Object key)的作用是删除key值对应的Node，该方法的具体逻辑是在removeNode(hash(key), key, null, false, true)里实现的。

jdk1.8的删除逻辑实现比较复杂，相比jdk1.7而言，多了红黑树节点删除和调整：

1. 默认判断链表第一个元素是否是要删除的元素；
2. 如果第一个不是，就继续判断当前冲突链表是否是红黑树，如果是，就进入红黑树里面去找；
3. 如果当前冲突链表不是红黑树，就直接在链表中循环判断，直到找到为止；
4. 将找到的节点，删除掉，如果是红黑树结构，会进行颜色转换、左旋、右旋调整，直到满足红黑树特性为止。

总结

1. HashMap是一种散列表，采用（数组 + 链表 + 红黑树）的存储结构；

2. HashMap的默认初始容量为16（1<<4），默认装载因子为0.75f，容量总是2的n次方；

3. HashMap扩容时每次容量变为原来的两倍；

4. 当桶的数量小于64时不会进行树化，只会扩容；

5. 当桶的数量大于64且单个桶中元素的数量大于8时，进行树化；

6. 当单个桶中元素数量小于6时，进行反树化；

7. HashMap是非线程安全的容器；

8. HashMap查找添加元素的时间复杂度都为O(1)；