HashMap
HashMap原理讲解
原理： HashMap是由数据+链表+红黑树的形式组成的 数组：是一块连续的存储空间，存储的每一个元素都有自己的下标 优点：寻址容易，通过下标可以快速的访问到元素，索引速度快 缺点：大小固定，数组中的空间放满了，需要重新建立新数组，复制原有数组到新数组中，并且插入和删除困难 链表：每一个元素存储下一个元素的内存地址，链式存储，存储元素离散 优点：添加元素快速，只需要将上一个元素指向自己，自己存储下一个元素的地址，插入和删除容易 缺点：没有索引下标，寻址困难，每次查找元素都需要从头部从新遍历，依次查找
HashMap底层的数据结构是hash散列表，结合了数组+链表两种数据结构。既满足了数组的查找方便，也不需要占用太大的内存空间。
采用Node（继承自Entry）数组来存储key-value的键值对，一个Node对应一个键值对，Node类是一个单向链表的结构，
通过next（Node类型）指针连接下一个Node节点(解决hash冲突问题)。
Node是HashMap的一个静态内部类，有key,value,hash,next是个属性。
key,value即存储的是每个节点的键值对，
hash 存储对应节点的hash值（并不是key的直接hash,而是(h = key.hashCode()) ^ (h >>> 16)，后边会对此方法详细讲解）
next 是一个指针，用来记录下一个元素
==当链表的长度超过8并且数组长度超过64之后链表将会转换为红黑树结构==
如图：
HashMap相关属性介绍
HashMap中的几个重要属性如下：
/**
*
* 缺省的table容量（不指定的话为16），必须是2的幂
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
*
* table的最大容量，必须是2的幂
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
*
* 默认的负载因子（不指定的话为0.75）
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
*
* 链表转为红黑树的阈值，代表的是链表长度的阈值
*/
static final int TREEIFY_THRESHOLD = 8;
/**
*
* 红黑树降级为链表的阈值，代表的是链表长度的阈值
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
*
* 链表转为红黑树的阈值，代表的是哈希表数组长度（超过64）
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
*
* 哈希表
*/
transient Node<K,V>[] table;
/**
*
* 当前hash表的元素个数
*/
transient int size;
/**
*
* 当前哈希表的结构修改次数（元素的添加，删除，数组的扩容会修改此值，元素的替换不会修改）
*/
transient int modCount;
/**
*
* 扩容阈值，当哈希表中的元素超过阈值时，触发扩容
*
*/
int threshold;
/**
*
* 负载因子
* threshold = capacity * loadFactor
*
*/
final float loadFactor;
构造方法源码解析
HashMap中有四个构造方法：
-
两个参数的构造方法： initialCapacity 初始的哈希表长度，loadFactor 负载因子 HashMap(int initialCapacity, float loadFactor)；
-
一个参数的构造方法，其实调的还是两个参数的构造方法
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
- 无参构造 构造一个具有默认初始容量 (16) 和默认负载因子 (0.75) 的空HashMap
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
- 使用与指定Map相同的映射构造一个新的HashMap 。 HashMap是使用默认负载因子 (0.75) 创建的，初始容量足以在指定的Map 中保存映射。 参数：m – 要在此地图中放置其映射的地图HashMap(Map<? extends K, ? extends V> m)
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
其实搞懂了两个参数的构造方法，其他的都很好理解，而且两个参数的构造方法也基本上描述了HashMap在创建时候所做的事情，下边来详细看一下两个参数的构造方法的代码：
/**
*
* @param initialCapacity 初始化的table的容量
* @param loadFactor 负载因子
*/
public HashMap(int initialCapacity, float loadFactor) {
// 对initialCapacity和loadFactor的校验
// 初始化table的容量小于0 抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// 初始化table的容量大于最大的容量， 将设置的初始容量设置为最大的table容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 负载因子小于0或者不是Float类型的数字抛出异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// 为哈希表设置传入的容量和负载因子
this.loadFactor = loadFactor;
// 当调用HashMap的构造方法创建对象的时候，在还没有往HashMap中放第一个元素之前（调用put方法），
// table对象还没有创建，threshold（扩容阈值）= capacity
// 当放进第一个元素的时候，此时会调用resize（扩容或者初始化table的大小）方法，此时会重新设置
// threshold = capacity * loadFactor
this.threshold = tableSizeFor(initialCapacity);
}
tableSizeFor方法做了什么事情呢，为什么要调用这个方法呢？其实是为了将传入的initialCapacity返回一个大于等于当前cap的数字，此数字一定是2的次方数。下边来研究一下这个方法是怎么回事。
/**
* Returns a power of two size for the given target capacity.
*
* 布尔运算 (用 1 代表 true，0 代表 false)：
*
*
* 与：1 & 1 = 1, 1 & 0 = 0, 0 & 1 = 0, 0 & 0 = 0;
*
*
* 或：1 | 1 = 1, 1 | 0 = 1, 0 | 1 = 1, 0 | 0 = 0;
*
*
* 非：~0 = 1, ~1 = 0;
*
* 作用：返回一个大于等于当前cap的数字，此数字一定是2的次方数
* cap = 10
* n = 10-1 = 9
* n转换为二进制 -> 0b1001
* n >>> 1即n向右移一位 0b0100
* 0b1001 | 0b0100 >>> 0b1101
* 0b1101 | 0b0011 >>> 0b1111
* 0b1111 | 0b0000 >>> 0b1111
* ……
* 所以最后n = 0b1111,转换为十进制为15
* 通过 (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
* 计算之后返回16；
*/
static final int tableSizeFor(int cap) {
// 此处减去1是为了获取最接近传入数字的2的次方数，避免创建更大的数组，浪费内存资源。
// 比如传入的是8, 最后的返回值是16，而我们希望的是8（请各位自己计算）
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;
}
put方法源码解析
在调用put方法的时候有两个关键的函数，hash（）和putVal（）
public V put(K key, V value) {
// hash(key) 计算哈希值
return putVal(hash(key), key, value, false, true);
}
hash方法并不是直接把key的hash值作为数组的hash值，而是考虑到了在哈希表中的为了避免频繁的哈希碰撞，让元素更均匀的分布在哈希表中所做的一次扰动，所以这个方法也称之为扰动函数。
此方法很简单 ==hash = (h = key.hashCode() ^ (h >>> 16));==
为什么要进行h >>> 16的操作呢？ 右位移16位，正好是32bit的一半，自己的高半区和低半区做异或，就是为了混合原始哈希码的高位和低位，以此来加大低位的随机性。而且混合后的低位掺杂了高位的部分特征，这样高位的信息也被变相保留下来
如果想深入了解，可以参考 HashMap之扰动函数和低位掩码.
下边就来看一下获取hash值的代码吧！
/**
*
* 作用：让key的hash值的高16位也参与路由运算
* 异或：相同返回0，不同返回1
* 假如key的hash为 0b1011 1101 0011 0110 1001 0001 1111 1110, 那么
*
* h 0b1011 1101 0011 0110 1001 0001 1111 1110
* ^
* h>>>16 0b0000 0000 0000 0000 1011 1101 0011 0110
* result 0b1011 1101 0011 0110 0110 0001 0010 1001
*
* 计算元素在table上的存储位置的算法是 (L-1) & hash,由于开始的时候table的长度比较小，
* 并且都是2的整次幂，那么L-1的二进制最后一定都是1，其余都是0
* 16-1=15。2进制表示是00000000 00000000 00001111。和某散列值做“与”操作如下
*
* 10111101 00110110 01100001 00101001
* &
* 00000000 00000000 00000000 00001111
* 00000000 00000000 00000000 00001001 //高位全部归零,只保留末四位
*
*
*/
static final int hash(Object key) {
int h;
// 扰动hash算法
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
下边就来看一下存储元素的核心代码putVal方法到底做了什么事情！代码中有详细的注释。
/**
* Implements Map.put and related methods.
*
* @param hash key的hash值
* @param key the key
* @param value the value to put
* @param onlyIfAbsent 如果为true,表示如果key相同，不覆盖value
* @param evict 如果为 false，则表处于创建模式
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// tab 引用当前hashmap的散列表
// p 表示当前散列表的元素
// n 表示当前数组的长度
// i 表示路由寻址的结果
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果table（散列表）为空或者里边没有元素，对散列表进行初始化（调用resize方法）
// 在创建 HashMap 对象的时候并没有对table进行初始化，是为了避免创建HashMap之后，并不在里边放置元素，
// 导致内存的浪费，所以在第一次调用putVal进行初始化最消耗内存的散列表
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 最简单的情况，寻址找到的桶位（table的下标）正好是null，这个时候将key-value封装成Node对象，并放在i的位置
// (n - 1) & hash 计算元素的桶位
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 桶位上已经有了相应的元素
else {
// e node临时元素，不为null的话，找到了一个与要插入的key-value一致的key的元素
// k 表示临时元素的key
Node<K,V> e; K k;
// 如果将要放置的元素的hash值和此桶位的元素一样，并且key的值相等，表示后续将要进行替换操作
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);
// 此桶位的结构是链表结构，并且链表的头元素和要插入的key不一致
else {
// 对链表进行循环，binCount表示此链表有多少元素
for (int binCount = 0; ; ++binCount) {
// 如果循环到下一个元素是null，表示此时的元素是最后一个元素，将临时元素放在尾端
if ((e = p.next) == null) {
// 将临时元素放在尾端
p.next = newNode(hash, key, value, null);
// 如果此链表的长度达到了转换为树形结构的条件，尝试转换为红黑树。下标-1为第一个元素
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 尝试转换为红黑树
treeifyBin(tab, hash);
break;
}
// 如果将要放置的元素的hash值和此桶位的元素一样，并且key的值相等，说明找到了相同key的node元素，需要进行替换操作
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 将临时元素赋值给p，此时的e是p的下一个元素(e = p.next)
p = e;
}
}
// e != null，表示此时的元素不是最后一个元素，即找到了一个相同key的node元素，需要进行value替换操作
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 增加散列表结构变化的次数
++modCount;
// 插入新元素，size自增，如果自增后的值大于扩容阈值，则触发扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
resize(扩容)方法源码解析
除了putVal方法还有一个很重要的方法，就是扩容方法resize。 resize方法也有很多设计巧妙的地方，很多地方值得我们去学习。下边来详细看一下其中的奥妙。
为了便于理解这个方法，在开始之前先说一下扩容前后的计算方法
假如扩容前的扩容大小 c1=16,那么扩容之后的 c2 = 16*2=32; 而计算在哈希表中桶位的函数是 ==i= （c-1）& hash==
假如旧表下标为15的所有元素计算下标
即 16-1 & hash = 15
转换为二进制就是
1111
& hash值
res 1111
那么hash的后四位一定是1111，所以hash的后五位是11111或者01111。
扩容之后计算下标就是
1 1111
& 1 1111
res 1 1111 -> 31
或者
1 1111
& 0 1111
res 0 1111 -> 15
所以在旧表中的原始下标c1在扩容后的新表中的下标只能是（i为旧表中的下标位置）
c2 = i
或者
c2 = c1 + i
知道了以上的结论再来看一下resize方法：
/**
*
* 为什么需要扩容？
* 为了解决哈希冲突导致的链化影响查询效率的问题，扩容会缓解该问题
*
* @return the table
*/
final Node<K,V>[] resize() {
// oldTab 引用扩容前的哈希表
Node<K,V>[] oldTab = table;
// oldCap 扩容之前的table的数组长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// oldThr 表示扩容前的扩容阈值，触发本次扩容的阈值
int oldThr = threshold;
// newCap 扩容之后的table的数组长度
// newThr 扩容之后的扩容阈值
int newCap, newThr = 0;
// 表示哈希表已经初始化过了，这是一次正常的扩容
if (oldCap > 0) {
// 扩容之前的数组大小已经达到了最大阈值后，则不扩容，且设置扩容条件为Integer.MAX_VALUE
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 如果oldCap左移一位实现数值翻倍，赋值给newCap，newCap小于最大的数组最大的长度，且扩容之前的数组长度小于16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 新的扩容阈值翻倍
newThr = oldThr << 1; // double threshold
}
// oldCap == 0，说明散列表是null，还没有进行初始化
// 1. new HashMap(int initialCapacity, float loadFactor)；
// 2. new HashMap(int initialCapacity)；
// 3. new HashMap(Map<? extends K, ? extends V> m); 并且m有数据
else if (oldThr > 0) // initial capacity was placed in threshold
// 将扩容前的扩容阈值赋值给table的数组长度
newCap = oldThr;
// oldCap == 0，oldThr == 0
// new HashMap()；
else { // zero initial threshold signifies using defaults
// 使用默认值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// newThr为0，通过newCap * loadFactor计算出newThr
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;
// 说明哈希表本次扩容之前table不为null，已经进行过初始化
if (oldTab != null) {
// 对旧的哈希表进行循环
for (int j = 0; j < oldCap; ++j) {
// 当前node的节点
Node<K,V> e;
// 说明当前桶位上有数据，但是不确定是单个元素，还是链表，还是红黑树
if ((e = oldTab[j]) != null) {
// 将老数组此桶位上的数据置空，方便JVM GC时回收，节省内存
oldTab[j] = null;
// 如果当前node节点的下一个元素是空的，表示为单个元素
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变量
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的HashMap,等之后有时间我会出一篇JDK7 和JDK8的比较篇，还有HashMap一些其他方法的源码解读。
HashMap的源码中其实有很多设计非常巧妙的地方，非常值得大家学习这种编程的思想。我本人也从中学习到了很多精华，以后再工作中要学以致用。
HashMap家族还有很多的内容没有写出来，但是这篇文章对于理解HashMap的基本结构和逻辑应该没问题。文中有错误之处请各位大佬指正出来。
