hashMap是这样一种数据结构，它可以实现时间复杂度为O（1）添加、删除、查询数据等操作。数据结构的物理存储结构只有两种：顺序存储结构（如数组）和链式存储结构（如链表），在数组中根据下标查找某个元素，一次定位就可以达到，哈希表利用了这种特性，哈希表的主干就是数组。
比如我们要新增或查找某个元素，我们通过把当前元素的关键字 通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作：
存储位置 = f(Key)
这个函数就称为哈希函数，会有这样的情况出现：不同的Key经过哈希函数的处理后，得到相同的存储地址，称为哈希冲突。这个函数的设计好坏会直接影响到哈希表的优劣。
哈希冲突是不可避免的，因为Key的值是无限而存储位置是有有限的，但是好的哈希函数可以尽量使数据的存储位置分散，减少哈希冲突。HashMap中采用的是链地址法（分离链接法），也就是数组+链表的方式。
JDK1.8对HashMap做个较大的修改。
在JDK1.8之前：
底层实现
HashMap的底层实现是数组加链表，如图：
HashMap的主要成员变量：
//HashMap的主干数组，可以看到就是一个Entry数组，
transient Entry<K,V>[] table;
//实际存储的key-value键值对的个数
transient int size;
//阈值，初始容量默认为DEFAULT_INITIAL_CAPACITY =16,当table被填充了，也就是为table分配内存空间后，threshold一般为 capacity*loadFactory
int threshold;
//负载因子，代表了table的填充度有多少，默认是0.75
final float loadFactor;
static final int DEFAULT_INITIAL_CAPACITY = 16;
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
Entry是HashMap中的一个静态内部类。代码如下：
final K key;
V value;
Entry<K,V> next;
int hash;
其中Entry<K,V>[] table数组是HashMap的核心，记录HashMap的所有数据，数组的每一个下标都对应者一条链表，用于存放产生哈希冲突的数据。从Entry的代码只有next可以看出，链表的类型是一个单向链表。
从Put方法分析HashMap的底层原理：
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key);
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;
}
- HashMap允许Key值为null，存放在table[0]处：
if (key == null){
return putForNullKey(value);
}
- 计算Key的hashCode值并根据hashCode和table的长度计算插入值在table数组中的下标：
int hash = hash(key);
int i = indexFor(hash, table.length);
static int indexFor(int h, int length) {
return h & (length-1);
}
h & (length-1)的作用是把hashCode进行一定的变换，保证计算后的i不会超过table的长度。由于length的取值一定是2的幂，length-1的低位全部是1，高位是0，如果h的值超过length，&运算后的值也会落在length范围内，例如：
1111 0010 1010&0000 1111 1111=0000 0010 1010
length的取值一定是2的幂的好处：
为了降低哈希冲突
- for循环中的代码：
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;
}
}
判断该条链上是否有hash值相同的Key) ，若存在相同，则直接覆盖value，直接返回旧oldValue。否则修改次数modCount+1，把当前key，value添加到table[i]的链表中。
- addEntry(hash, key, value, i)
如果size超过阈值并且要插入的键值对要占的位置不是null，就要对数组进行扩容。扩容后要重新计算一次hash值和下标。
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 resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
//将元数组中的元素转移到新的数组中
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
并通过transfer方法，移动元素。
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
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;
}
}
}
扩容主要完成以下工作：
（1）根据新的容量（原容量的2倍）确定新的阈值大小threshold。
（2）确定是否要哈希重构（rehash）。
（3）调用transfer方法计算当前所有节点在新table中的下标。因为是头插法，因此新旧链表的元素位置会发生转置现象。
元素迁移的过程中在多线程情境下有可能会触发死循环（无限进行链表反转）
HashMap扩容过程中的死循环问题
发生场景：
1.多线程
2.扩容
3.JDK1.7及之前版本
案例分析：
假设HashMap初始化大小为4，插入个3节点，不巧的是，这3个节点都hash到同一个位置，如图所示：
插入第4个节点时，发生resize，假设现在有两个线程同时进行，线程1和线程2，两个线程都会新建新的数组。
假设 线程2 在执行到Entry<K,V> next = e.next;之后，cpu时间片用完了，这时变量e指向节点a，变量next指向节点b。
线程1继续执行，很不巧，a、b、c节点rehash之后又是在同一个位置7，开始移动节点，该方法实现的机制就是将每个链表转化到新链表，并且链表中的位置发生反转，移动后节点在数组中的位置如图：
这个时候 线程1 的时间片用完，内部的table还没有设置成新的newTable，线程2 开始执行，这时内部的引用关系如下：
变量e指向节点a，变量next指向节点b
这时，在 线程2 中，变量e指向节点a，变量next指向节点b，但是这时b已经指向a了（初始状态b的next指向c，线程一导致b指向a），开始执行循环体的剩余逻辑。
执行一次这四行代码：
Entry<k,v> next = e.next;
e.next = newTable[i];
newTable[i] = e;
e = next;
执行之后的引用关系如下图
执行后，变量e指向节点b，因为e不是null，则继续执行循环体，执行后的引用关系
变量e又重新指回节点a，继续执行循环体，这里仔细分析下：
1、执行完Entry<K,V> next = e.next;，目前节点a没有next，所以变量next指向null；
2、e.next = newTable[i]; 其中 newTable[i] 指向节点b，那就是把a的next指向了节点b，这样a和b就相互引用了，形成了一个环；
3、newTable[i] = e 把节点a放到了数组i位置；
4、e = next; 把变量e赋值为null，因为第一步中变量next就是指向null；
所以最终的引用关系是这样的：
节点a和b互相引用，形成了一个环，当在数组该位置get寻找对应的key时，就发生了死循环。
另外，如果线程2把newTable设置成到内部的table，节点c的数据就丢了，看来还有数据遗失的问题。
JDK1.8中不会出现死循环：
JDK 8 中采用的是位桶 + 链表/红黑树的方式，当某个位桶的链表的长度超过 8 的时候，这个链表就将转换成红黑树
HashMap 不会因为多线程 put 导致死循环（JDK 8 用 head 和 tail 来保证链表的顺序和之前一样；JDK 7 rehash 会倒置链表元素），但是还会有数据丢失等弊端（并发本身的问题）。因此多线程情况下还是建议使用 ConcurrentHashMap
JDK1.8
HashMap是的底层是数组+链表+红黑树，当链表长度大于8时转换成红黑树，红黑树节点数小于6时转换成链表。这样中间有个差值7可以有效防止链表和树频繁转换。假设一下，如果设计成链表个数超过8则链表转换成树结构，链表个数小于8则树结构转换成链表，如果一个HashMap不停的插入、删除元素，链表个数在8左右徘徊，就会频繁的发生树转链表、链表转树，效率会很低。
JDK1.8中 改用Node替代Entry：
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
put方法：
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;
/*如果table的在（n-1）&hash的值是空，就新建一个节点插入在该位置*/
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
/*表示有冲突,开始处理冲突*/
else {
Node<K,V> e;
K k;
/*检查第一个Node，p是不是要找的值*/
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个，看是否需要改变冲突节点的存储结构，
//treeifyBin首先判断当前hashMap的长度，如果不足64，只进行
//resize，扩容table，如果达到64，那么将冲突的存储结构为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
/*如果有相同的key值就结束遍历*/
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
/*就是链表上有相同的key值*/
if (e != null) { // existing mapping for key，就是key的Value存在
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;//返回存在的Value值
}
}
++modCount;
/*如果当前大小大于门限，门限原本是初始容量*0.75*/
if (++size > threshold)
resize();//扩容两倍
afterNodeInsertion(evict);
return null;
}
下面简单说下添加键值对put(key,value)的过程：
1，判断键值对数组tab[]是否为空或为null，否则以默认大小resize()；
2，根据键值key计算hash值得到插入的数组索引i，如果tab[i]==null，直接新建节点添加，否则转入3
3，判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理
扩容过程：
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)
newThr = oldThr << 1; // double threshold
}
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)
//如果节点不为null，且没有next节点，那么重新计算该节点hash值，存入新的table中。
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;
}
扩容后需要把旧数组中的节点重新计算放入到新数组中，处理过程如下：
（1）如果节点为null，不处理。
（2）如果节点不为null，且没有next节点，那么重新计算该节点hash值，存入新的table中。
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
（3）如果节点是红黑树，调用split方法处理。
（4）否则说明节点是链表节点，这里分为两种情况：
元素在重新计算hash之后，因为length变为2倍，那么length-1的二进制码范围在高位多1bit，因此新的index就会发生这样的变化：
简单说就是，如果多出来的一位的hashCode值是0，那么不需要处理，放入到新数组中的相同下标处。如果多出来的hashCode的值是1，那么节点放入新数组时位置就要变成：新下标=原下标+旧容量。这是一个巧算，利用的是数组容量必然是2的指数的特征。
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
