HashMap是Java中的一种散列表，存储键值对，通过哈希函数定位元素。内部使用Entry数组和链表解决哈希碰撞，初始容量和负载因子影响其性能。插入和查找操作时间复杂度为O(1)，但不保证线程安全。在多线程环境下可能导致数据不一致或CPU利用率100%，JDK1.8改进了resize操作以避免链表环路问题。
1.HashMap简介
HashMap继承自AbstractMap，AbstractMap是Map接口的骨干实现，AbstractMap中实现了Map中最重要最常用和方法，这样HashMap继承AbstractMap就不需要实现Map的所有方法，让HashMap减少了大量的工作。HashMap是一个散列表，它存储的内容是键值对(key-value)映射。
2.数据结构
从上图我们可以形象的了解HashMap的数据结构，纵向代表的是Entry数组，数组中存储着单链表。当HashMap中要插入元素时，首先计算出对应的哈希值，从而确定对应的数组Index，若该Index中没有元素，则直接插入，若有元素，则产生哈希碰撞，解决方法是将新元素插入到链表头。数组的存储方式在内存的地址是连续的，大小固定，一旦分配不能被其他引用占用。它的特点是查询快，时间复杂度是O(1)，插入和删除的操作比较慢，时间复杂度是O(n)，链表的存储方式是非连续的，大小不固定，特点与数组相反，插入和删除快，查询速度慢。HashMap可以说是一种折中的方案吧。
3.成员变量：
size指的是初始化HashMap时指定的容量，负载因子指定了当存储内容达到最大容量的百分之多少时HashMap扩容（对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+n)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认负载因子为0.75，一般情况下我们是无需修改的。），modCount变量在ArrayList类中也用到了，它的作用是若使用Iterator遍历时发生add或remove操作，则遍历”快速失败“，因为每遍历一个元素就会检查modCount是否被修改，而add和remove操作都会对modCount++。threshold是负载因子与size的乘积，它表示当存储内容达到该临界值，则对HashMap进行扩容。Entry是JAVA的一个类，它定义的数据结构用于存储HashMap中的元素。
transient HashMap.Node<K, V>[] table;
static class Node<K,V> implements Map.Entry<K,V> {
//Hash值
final int hash;
//Key值
final K key;
//Value值
V value;
//当前Node对应的下个Node(用于解决Hash冲突)
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;
}
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
}*transient关键字使用小结：
Java transient关键字使用小记
private abstract class HashIterator<E> implements Iterator<E> {
Entry<K,V> next; // next entry to return
int expectedModCount; // For fast-fail
int index; // current slot
Entry<K,V> current; // current entry
HashIterator() {
expectedModCount = modCount;
if (size > 0) { // advance to first entry
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
}
public final boolean hasNext() {
return next != null;
}
final Entry<K,V> nextEntry() {
// 这里就是关键
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
if ((next = e.next) == null) {
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
current = e;
return e;
}
public void remove() {
if (current == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Object k = current.key;
current = null;
HashMap.this.removeEntryForKey(k);
expectedModCount = modCount;
}
}4.构造方法：
public HashMap(int initialCapacity, float loadFactor) {
// initialCapacity代表初始化HashMap的容量，它的最大容量是MAXIMUM_CAPACITY = 1 << 30。
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// loadFactor代表它的负载因子，默认是是DEFAULT_LOAD_FACTOR=0.75，用来计算threshold临界值的。
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// Find a power of 2 >= initialCapacity
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
this.loadFactor = loadFactor;
threshold = (int)(capacity * loadFactor);
table = new Entry[capacity];
init();
}由上面的代码可以看出，初始化的时候需要知道初始化的容量大小，且容量不能超过1 << 30。在分配Entry数组时，要求Entry的数组长度是2的N次方（>=initialCapacity）,原因在下文会叙述。
5.主要方法源码分析
- put（K,V）方法：
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}1. 如果为null，则调用putForNullKey：这就是为什么HashMap可以用null作为键的原因，来看看HashMap是如何处理null键的：
private V putForNullKey(V value) {
//查找链表中是否有null键
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
//如果链中查找不到，则把该null键插入
addEntry(0, null, value, 0);
return null;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
//这一步就是对null的处理，如果key为null，hash值为0，也就是会插入到哈希表的表头table[0]的位置
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}在上面这段代码中，我们可以看到，putForNullKey方法首先遍历table[0]的链表，若找到key为null的Entry，则将新的value替换旧的value，并将旧的返回；若未找到，则调用addEntry方法插入null值。在addEntry方法源码中，我们可以看到，若HashMap容量不够，则先扩容，然后计算hash值（若key为null，则hash值为0），否则，计算key的hashcode，再用计算的结果调用hash方法：
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
h ^= k.hashCode();
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}hash(int h)方法根据key的hashCode重新计算一次散列。此算法加入了高位计算，防止低位不变，高位变化时，造成的hash冲突。
static int indexFor(int h, int length) {
return h & (length-1);
}indexFor方法的作用是计算该hash值对应的数组下标，对于HashMap的table而言，数据分布需要均匀（最好每项都只有一个元素，这样就可以直接找到，而无需遍历列表），不能太紧也不能太松，太紧会导致查询速度慢，太松则浪费空间。计算hash值后，怎么才能保证table元素分布均与呢？一种方案是取模，但是由于取模的消耗较大，HashMap是通过&运算符（按位与操作）来实现的：h & (length-1)。
在前文中提到过，hashMap的数组大小总是2的N次方，当length为2的n次方时，h&(length - 1)就相当于h对length取模，而且速度比直接取模快得多，除此之外，这种方法还能让table中的数据尽量均匀分布，从而减少了空间浪费。
这里我们假设length为16(2^n)和15，h为5、6、7。
当length-1 = 14时，6和7的结果一样，这样表示他们在table存储的位置是相同的，也就是产生了碰撞，6、7就会在一个位置形成链表，这样就会导致查询速度降低详细地看看当length-1 = 14 时的情况：
可以看到，这样发生发生的碰撞是非常多的，1,3,5,7,9,11,13都没有存放数据，空间减少，进一步增加碰撞几率，这样就会导致查询速度慢，
分析一下：当length-1 = 14时，二进制的最后一位是0，在&操作时，一个为0，无论另一个为1还是0，最终&操作结果都是0，这就造成了结果的二进制的最后一位都是0，这就导致了所有数据都存储在2的倍数位上（相同道理，若length-1有某位是0，那么所有数据就会存储到2的i次方倍数位上），所以说当length = 2^n时，length-1每一位都是1，不同的hash值发生碰撞的概率比较小，这样就会使得数据在table数组中分布较均匀，查询速度也较快。
2. 若key不为null，那么计算key的hash值，根据hash值搜索在哈希表table中的索引位置，若当前索引位置不为null，则对该位置的Entry链表进行遍历，如果链中存在该key，则用传入的value覆盖掉旧的value，同时把旧的value返回，结束；否则调用addEntry，用key-value创建一个新的节点，并把该节点插入到该索引对应的链表的头部。
- get（K）方法：
public V get(Object key) {
2 if (key == null)
3 return getForNullKey();
4 // 获取key的hash值
5 int hash = hash(key.hashCode());
6 // 在“该hash值对应的链表”上查找“键值等于key”的元素
7 for (Entry<K,V> e = table[indexFor(hash, table.length)];
8 e != null;
9 e = e.next) {
10 Object k;
11 if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
12 return e.value;
13 }
14 return null;
15 }读取的步骤比较简单，调用hash（key）求得key的hash值，然后调用indexFor（hash）求得hash值对应的table的索引位置，然后遍历索引位置的链表，如果存在key，则把key对应的Entry返回，否则返回null。
6.JDK1.8中HashMap的更新
线程不安全！
我们知道，HashMap是线程不安全的，也就是说多个线程同时执行put操作会出现数据不一致的问题。在HashMap中，迭代器Iterator是基于”快速失败“机制的。它通过维护一个modcount变量来记录当前HashMap是否被“修改”过。也就是说当put，remove等修改操作成功时，会使modcount变量++（modcount变量是volatile修饰的，保证线程间的可见性），当执行迭代时，先读取当前modcount，在iterator每次遍历时比较modcount是否被修改，若修改则抛出ConcurrentModificationException异常。
另外，在JDK1.8之前，HashMap的Resize操作会造成链表循环，导致CPU飙升100%（原因请看HashMap中的resize以及死链的情况 - 一枝花算不算浪漫 - 博客园，讲的很详细！）综合其主要原因，应归结于rehash之后插入的节点顺序与原table中顺序相反（假设A->B原来在1号桶，resize必然要rehash，这里假设重新hash后A,B还在1号桶，那么它们的顺序就会变B->A）！所以多线程才导致环路形成。
在JDK1.8中，对Resize方法进行了改写，提升了效率，解决了环路形成问题。主要原因是JDK1.8rehash重新插入后不会反序！，并且因为所有hashmap的size都是2的n次方，所以就有一个性质，A元素rehash后要么在原来的桶，要么在原来的桶号+原来的size。
举个例子：
// 示例1：
// e.hash=10 0000 1010
// oldCap=16 0001 0000
// & =0 0000 0000 比较高位的第一位 0
//结论：元素位置在扩容后数组中的位置没有发生改变
// 示例2：
// e.hash=17 0001 0001
// oldCap=16 0001 0000
// & =1 0001 0000 比较高位的第一位 1
//结论：元素位置在扩容后数组中的位置发生了改变，新的下标位置是原下标位置+原数组长度
也就是说，我们只需要关注hash值与oldCap的&是否为1就可判断rehash后桶的序号！我们知道，&运算的速度是很快的，这样就避免了重新计算hash值的时间浪费。
JDK7Resize核心方法：
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {//直接遍历table变量
//链表跟table[i]断裂遍历，头部往后遍历插入到newTable中
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}JDK8Resize核心代码：
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {//开始遍历oldTable
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null) //table[i]没值
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode) //table[i]是红黑树的结构
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { //table[i]是链表的结构，扩容后还是保持顺序的
Node<K,V> loHead = null, loTail = null; //“低链表”的头和尾，即扩容后的在new table的index和old index是一样的
Node<K,V> hiHead = null, hiTail = null; //“高链表”的头和尾，即扩容后的在new table的index是old index的2倍
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {//newTable index == oldTable index
if (loTail == null)
loHead = e;//头只当初始时才赋值
else
loTail.next = e;//新插入的都到添加到tail中
loTail = e;
}
else {//newTable index == oldTable index * 2
if (hiTail == null)
hiHead = e;//头只当初始时才赋值
else
hiTail.next = e;//新插入的都到添加到tail中
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) { //将“低链表”添加到newTable中
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {//将“高链表”添加到newTable中
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}参考资料：
Java基础系列之(三) - HashMap深度分析
Java容器（四）：HashMap（Java 7）的实现原理
https://blog.csdn.net/Lin_wj1995/article/details/83899208
扫一扫
419
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
