源码之HashMap

前言

HashMap是Map的一种实现，它存放的形式是以key-value形式存放的。但是底层HashMap这种数据结构是怎么实现的呢？是以什么数据结构实现的存储呢？这篇文章也是我自己对这些问题的一个总结与深入学习，同时也为了跟同事做知识分享，作为码字练手。本篇文章除了分析上面的几个问题，我也会深入到HashMap的源码，去阅读分析HashMap的实现者所写的算法实现。

因为在同版本的JDK中，对Map实现的数据结构所采用算法是不同的，同时不同版本JDK相同数据结构实现也有差异，而这种差异值得我们去思考和分析，这里面所包含的东西，是没有深入源码的你所无法体会的，这里会给我们带来智商上不断的冲击（可能有些夸张，但如果你有兴趣读下去，那么一定发现很多有趣知识）。这篇文章罗列JDK7和JDK8中HashMap进行源码阅读分析，如果你想了解更多，可以查阅更早版本的实现，以及更新版本的实现。

---

必备知识

Hash

Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

备注：通过hash函数返回的hash值如果不相同，那么值肯定不相同；如果返回的hash值相同，不能确定值相同。原因会在后续详细说明hash算法原理时进行解释说明。

碰撞

所谓的发生碰撞，就是两个不相同的值，通过hash函数返回的hash值相同，那么我们就说发生了碰撞。

常见hash算法

直接定址法：直接以关键字k或者k加上某个常数（k+c）作为哈希地址。
数字分析法：提取关键字中取值比较均匀的数字作为哈希地址。
除留余数法：用关键字k除以某个不大于哈希表长度m的数p，将所得余数作为哈希表地址。
分段叠加法：按照哈希表地址位数将关键字分成位数相等的几部分，其中最后一部分可以比较短。然后将这几部分相加，舍弃最高进位后的结果就是该关键字的哈希地址。
平方取中法：如果关键字各个部分分布都不均匀的话，可以先求出它的平方值，然后按照需求取中间的几位作为哈希地址。
伪随机数法：采用一个伪随机数当作哈希函数。

备注：衡量一个哈希函数的好坏的重要指标就是发生碰撞的概率以及发生碰撞的解决方案。任何哈希函数都无法彻底避免碰撞

常见碰撞解决方案

开放定址法
开放定址法就是一旦发生了冲突，就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将记录存入。

链地址法
将哈希表的每个单元作为链表的头结点，所有哈希地址为i的元素构成一个同义词链表。即发生冲突时就把该关键字链在以该单元为头结点的链表的尾部。

再哈希法
当哈希地址发生冲突用其他的函数计算另一个哈希函数地址，直到冲突不再产生为止。

建立公共溢出区
将哈希表分为基本表和溢出表两部分，发生冲突的元素都放入溢出表中。

HashMap数据结构

java中最常见两种数据结构：数组和链表，事实上很多Java数据集结构都是通过他两实现的，比如说ArrayList和Vector就是数组实现的，LinkedList是双向链表实现的。数组：寻址快，链表寻址慢；但是数组必须空间连续，而链表则不需要，同时数组增删慢，链表增删快。它们两者各有优缺点。而今天我们要学习的HashMap就是将数组和连接进行结合进行实现的，它可以很好的综合它们的优缺点。简单的说HashMap就是链表数组（数组元素是链表），也叫作桶数组。如下图：

根据上面的示意图，我们就不难理解这种结构，左边就是一个数组，而数组里面的元素就是一个单向链表。

分析：
左侧数组，h(k)是返回hash值作为当前值的数组地址，如果发生碰撞就采用链地址法解决。

---

源码解读

我们知道，hash方法的功能是根据Key来定位这个K-V在链表数组中的位置的。也就是hash方法的输入应该是个Object类型的Key，输出应该是个int类型的数组下标。

其实简单，我们只要调用Object对象的hashCode()方法，该方法会返回一个整数，然后用这个数对HashMap容量进行取模就行了。没错，其实基本原理就是这个，只不过，在具体实现上，由两个方法int hash(Object k)和int indexFor(int h, int length)来实现。但是考虑到效率等问题，HashMap的实现会稍微复杂一点。

Hash函数

jdk7中hash函数的实现，如下代码：

final int hash(Object k) {
   int h = hashSeed;
   if (0 != h && k instanceof String) {
       return sun.misc.Hashing.stringHash32((String) k);
   }

   h ^= k.hashCode();
   h ^= (h >>> 20) ^ (h >>> 12);
   return h ^ (h >>> 7) ^ (h >>> 4);
}

static int indexFor(int h, int length) {
   return h & (length-1);
}

indexFor方法其实主要是将hash生成的整型转换成链表数组中的下标。那么return h & (length-1);是什么意思呢？其实就是取模。Java之所有使用位运算(&)来代替取模运算(%)，最主要的考虑就是效率。因为位运算直接操作的是内存，它不需要转换，效率最理想。
那hash函数中为什么通过几次的位运算（>>>和^）呢？简单点说，就是为了把高位的特征和低位的特征组合起来，降低哈希冲突的概率，也就是说，尽量做到任何一位的变化都能对最终得到的结果产生影响。其根本是为了减低碰撞的概率，就是让高位和低位进行混合，达到尽可能在改变少数位时，依然能够得到不同的hash值，你们可以自行做验证，因为篇幅关系我就不在这里验证了。

JDK8中的hash函数：

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }

在jdk8中进行了优化，如上所示，但原理都是一样的都是为了通过扰动，然高位与地位混合，达到减低碰撞的效果。但是具体这种方式是否比jdk7的实现方式更加高效，或者是综合效率，碰撞概率更加好呢？这个 可以留个各位看官进行验证和思考。

容量与扩容

在说明之前我先贴出一些源码(JDK8)如下：

// 默认的初始容量是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认的填充因子(以前的版本也有叫加载因子的)
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 当桶(bucket)上的链表数大于这个值时会转成红黑树，put方法的代码里有用到
static final int TREEIFY_THRESHOLD = 8;
// 也是阈值同上一个相反，当桶(bucket)上的链表数小于这个值时树转链表
static final int UNTREEIFY_THRESHOLD = 6;
// 看源码注释里说是：树的最小的容量，至少是 4 x 
// TREEIFY_THRESHOLD = 32 
// 然后为了避免(resizing 和 treeification thresholds) 设置成64
static final int MIN_TREEIFY_CAPACITY = 64;
// 存储元素的数组，总是2的整数次幂
transient Node<k,v>[] table;
transient Set<map.entry<k,v>> entrySet;
// 存放元素的个数
transient int size;
// 每次扩容和更改map结构的计数器
transient int modCount;
// 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
int threshold;
// 填充因子
final float loadFactor;

分析：
上面的HashMap代码是JDK8中的，里面引入了这样一个红黑树转化触发值8，一旦桶超过8就转为红黑树。并且扩充的容量必须是2的整数次幂，接下来我们查询他的构造函数。

// 指定初始容量和填充因子的构造方法
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;
// 指定容量后，tableSizeFor方法计算出临界值，put数据的时候如果超出该值就会扩容，该值肯定也是2的倍数
// 指定的初始容量没有保存下来，只用来生成了一个临界值
this.threshold = tableSizeFor(initialCapacity);
}
// 该方法保证总是返回大于cap并且是2的倍数的值，比如传入999 返回1024
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;
}
//构造函数2
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//构造函数3
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

根据阿里巴巴Java开发手册上建议HashMap初始化时设置已知的大小，如果不超过16个，那么设置成默认大小16：
集合初始化时， 指定集合初始值大小。
说明： HashMap使用HashMap(int initialCapacity)初始化，
正例：initialCapacity = (需要存储的元素个数 / 负载因子) + 1。注意负载因子（即loader factor）默认为0.75， 如果暂时无法确定初始值大小，请设置为16（即默认值）。
反例：HashMap需要放置1024个元素，由于没有设置容量初始大小，随着元素不断增加，容量7次被迫扩大，resize需要重建hash表，严重影响性能。

我们可以通过下面这段代码测试：

int aHundredMillion = 10000000;

        Map<Integer, Integer> map = new HashMap<>();

        long s1 = System.currentTimeMillis();
        for (int i = 0; i < aHundredMillion; i++) {
            map.put(i, i);
        }
        long s2 = System.currentTimeMillis();

        System.out.println("未初始化容量，耗时 ： " + (s2 - s1));

        Map<Integer, Integer> map1 = new HashMap<>(aHundredMillion / 2);

        long s5 = System.currentTimeMillis();
        for (int i = 0; i < aHundredMillion; i++) {
            map1.put(i, i);
        }
        long s6 = System.currentTimeMillis();

        System.out.println("初始化容量5000000，耗时 ： " + (s6 - s5));

        Map<Integer, Integer> map2 = new HashMap<>(aHundredMillion);

        long s3 = System.currentTimeMillis();
        for (int i = 0; i < aHundredMillion; i++) {
            map2.put(i, i);
        }
        long s4 = System.currentTimeMillis();

        System.out.println("初始化容量为10000000，耗时 ： " + (s4 - s3));

备注：在JDK7与JDK8中你会得有差异的结果，请自行测试与思考。

接下来就是看它具体是如何扩容和重新构建hash表的，代码如下：

final Node<K,V>[] resize() {
        Node<K,V>[] 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;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                                         // 容量扩大为原来的两倍，oldCap大于等于16
                newThr = oldThr << 1; // 双倍
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            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;
                    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;
    }

上面的代码不难理解，而且都有注释。

我们在来看下jdk8中新进的角色红黑树，代码如下：

    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;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            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);
                        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;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
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)
            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);
        }
    }

上面就是jdk8中HashMap中put方法所调用的putVal方法实现，以及转为红黑树的代码。

总结：

0.HashMap底层是一个单链表数组结构实现的
1.HashMap的初始容量16
2.jdk8中，当达到触发值8，会转成红黑树结构（具体没有罗列，看源码了解更多）
3.HashMap不是线程安全的
4.hash采用了高低位异或混合方式降低碰撞概率
5.HashMap结合了数组与链表的优点
6.等等

上面贴了很多代码，其实如果要掰开揉碎说，估计可以出一本书。做技术的我想更应该沉下心来，阅读大神的代码短时间内不能够让你发家致富（现在社会太浮躁，太急功近利），但它可能给你带来不一样的头脑风暴。

通过对HashMap源码的分析，我们可以对HashMap这种数据结构有更加深入的了解。从中我们也体会到，虽然代码量不多，但Java作者对于每行代码，每种设计，以及每个算法的选取都是有所考虑的，这也启发我们JAVA开发者更多的思考，让我们在工作中也能够像java作者一样能够从细小的地方下功夫，把工作做好。也希望这篇文章能够给你带来一定的参考价值。

参考大神文章：
hash算法深入解析

转载于:https://blog.51cto.com/4837471/2309748