HashMap 是java 开发中使用频率最高的用于映射（键值对）处理的数据类型。随着JDK 版本的的更新，JDK1.8 对HashMap 底层的实现进行了优化，例如引入红黑树的数据结构和扩容的优化等。本文结合JDK1.7 和JDK1.8 两个目前主流的JDK版本的区别，深入探讨HashMap 的底层实现和功能原理。
在JDK1.8 之前，HashMap 的底层是数组和链表结合使用。HashMap 通过key 的hashCode 经过扰动函数处理之后得到hash 值，然后通过 (n - 1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。
而所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使用扰动函数之后可以减少碰撞。
JDK 1.8 HashMap 的 hash 方法源码:
static final int hash(Object key) {
int h;
// key.hashCode()：返回散列值也就是hashcode
// ^ ：按位异或
// >>>:无符号右移，忽略符号位，空位都以0补齐
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
JDK 1.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);
}
对比两者之间的hash 方法，原理大致相同，只是JDK 1.8 进行了一些简化。由源码可知，JDK 1.8 hash 方法的性能会高于JDK 1.7 的。
关于两者之间性能的对比，知乎上的美团技术团队在hash 较为均匀和hash 极不均匀两种情况下进行了性能测试，结果如下：
-
hash 较为均匀
通过观测测试结果可知，JDK1.8的性能要高于JDK1.7 15%以上，在某些size的区域上，甚至高于100%。由于Hash算法较均匀，JDK1.8引入的红黑树效果不明显，下面是Hash不均匀的的情况。 -
hash 极不均匀
从表中结果中可知，随着size的变大，JDK1.7的花费时间是增长的趋势，而JDK1.8是明显的降低趋势，并且呈现对数增长稳定。当一个链表太长的时候，HashMap会动态的将它替换成一个红黑树，这话的话会将时间复杂度从O(n)降为O(logn)。hash算法均匀和不均匀所花费的时间明显也不相同，这两种情况的相对比较，可以说明一个好的hash算法的重要性。
关于两者性能差距的原因除了JDK1.8 的hash 方法性能高之外，JDK1.8及之后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。而JDK1.7 则是使用拉链法来解决哈希冲突。
HashMap 的存储结构
从 HashMap 的存储结构的实现上看，HashMap是数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的。由源码可知，HashMap类中有一个非常重要的字段，即Node[] table，即哈希桶数组，它是一个Node 数组。下面是Node[JDK1.8] 的源码
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //用来定位数组索引位置
final K key;
V value;
Node<K,V> next; //链表的下一个node
Node(int hash, K key, V value, Node<K,V> next) { ... }
public final K getKey(){ ... }
public final V getValue() { ... }
public final String toString() { ... }
public final int hashCode() { ... }
public final V setValue(V newValue) { ... }
public final boolean equals(Object o) { ... }
}
Node是HashMap的一个内部类，实现了Map.Entry接口，本质是就是一个映射(键值对)。
当调用map.put() 方法时，系统将根据Key 的hashCode()方法得到其hashCode 值（该方法适用于每个Java对象），然后再通过Hash 算法的后两步运算（高位运算和取模运算）来定位该键值对的存储位置，有时两个key会定位到相同的位置，表示发生了Hash碰撞。当然Hash算法计算结果越分散均匀，Hash碰撞的概率就越小，map的存取效率就会越高。
如果哈希桶数组很大，即使较差的Hash算法也会比较分散，如果哈希桶数组数组很小，即使好的Hash算法也会出现较多碰撞，所以就需要在空间成本和时间成本之间权衡，其实就是在根据实际情况确定哈希桶数组的大小，并在此基础上设计好的hash算法减少Hash碰撞。好的hash 算法和扩容机制可以减小map 的碰撞概率并且使哈希桶数组（Node[] table）占用的空间少。
在理解Hash和扩容流程之前，我们得先了解下HashMap的几个字段。从HashMap的默认构造函数源码可知，构造函数就是对下面几个字段进行初始化，源码如下：
int threshold; // 所能容纳的key-value对极限
final float loadFactor; // 负载因子
int modCount; // 记录HashMap 内部结构发生变化（例如put，修改key对应的值不算）的次数
int size; // HashMap 中实际存在的键值对数量
Node[] table的初始化长度length(默认值是16)，Load factor为负载因子(默认值是0.75)，threshold是HashMap所能容纳的最大数据量的Node(键值对)个数。threshold = length * Load factor。由公式可知，负载因子（loadFactor）越大，所能容纳的最大键值对数越多。（不建议修改，在某些特殊情况下可以考虑修改）
在HashMap中，哈希桶数组table的长度length大小必须为2的n次方(一定是合数)，这是一种非常规的设计，常规的设计是把桶的大小设计为素数。HashMap采用这种非常规设计，主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap定位哈希桶索引位置时，也加入了高位参与运算的过程。
HashMap 中的方法实现
HashMap 的内部功能实现很多，以下是从根据Key 获取哈希桶数组索引位置、put 方法的源码、扩容过程等代表性较强的点进行分析。
- 确定哈希桶索引数组位置
不管增加、删除、查找键值对，定位到哈希桶数组的位置都是很关键的第一步。HashMap 的数据结构是数组和链表，所以我们希望HashMap 里面的元素分布的尽量均匀，最好使每个位置上的元素只有一个，这样当我们使用hash 算法求位置的时候，就能快速得到，而不需要去遍历链表。HashMap 定位数组索引位置，直接决定了hash方法的离散性能。
方法一：
static final int hash(Object key) { //jdk1.8 & jdk1.7
int h;
// h = key.hashCode() 为第一步 取hashCode值
// h ^ (h >>> 16) 为第二步 高位参与运算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
方法二：
static int indexFor(int h, int length) { //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
return h & (length-1); //第三步 取模运算
}
由源码可知，hash 算法的本质就是三步：取Key 的hashCode 值、高位运算、取模运算。
关于hash 算法的具体细节实现，大家有兴趣可以自己对着源码查询相关资料。
- 分析HashMap 的 put 方法
JDK1.8HashMap的put方法源码如下:
public V put(K key, V value) {
// 对key的hashCode()做hash
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;
// 步骤①：tab为空则创建
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 步骤②：计算index，并对null做处理
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 步骤③：节点key存在，直接覆盖value
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;
}
// key已经存在直接覆盖value
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
p = e;
break;
}
}
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;
}
如果有兴趣，大家可以去查询更过的相关资料
- 扩容机制
本人目前对JDK1.8 HashMap的扩容机制不是很了解，源码也还未读懂，等弄清楚了再来补上这部分的内容。
HashMap 的线程安全性
在多线程使用场景中，应该尽量避免使用线程不安全的HashMap，而使用线程安全的ConcurrentHashMap。主要原因在于 并发下的Rehash 会造成元素之间会形成一个循环链表。不过，jdk 1.8 后解决了这个问题，但是还是不建议在多线程下使用 HashMap,因为多线程下使用 HashMap 还是会存在其他问题比如数据丢失。
详情请查看：HashMap 多线程操作导致死循环问题
小结
- 1、扩容是一个特别耗性能的操作，所以在使用HashMap 时，估算map 的大小，初始化的时候给一个大致的数值，避免map 进行频繁的扩容。
- 2、负载因子是可以修改，也可以大于1，但是建议不要轻易修改，除非情况非常特殊。
- 3、HashMap是线程不安全的，不要在并发的环境中同时操作HashMap，建议使用ConcurrentHashMap。
- 4、JDK1.8引入红黑树大程度优化了HashMap的性能。
扫一扫
425
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
