版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Java集合源码实现三：HashMap (jdk1.8)
文章目录
- Java集合源码实现三：HashMap (jdk1.8)
- 类继承关系：
- 什么是HashMap
- HashMap数据结构
- 源码分析：
类继承关系：
什么是HashMap
基于哈希表的Map接口的实现。这个实现提供了所有可选的映射操作，并且允许null值和null键的键值对集合。
HashMap数据结构
在jdk1.8之前HashMap是基于桶数组和链表实现的。hashmap通过计算key的hash值来决定其在数组中的位置，因此其查询效率非常高。当出现相同的hash值的元素发生hash冲突时，则放在与他相同hash值元素的后面，构成一个单向链表。但是当hash冲突过多时，这个链表也会变的越长，其查询效率的优势就会消失，所以在jdk1.8之后，当这个链表长度大于8时就会转换为红黑树，在小于6时转换成链表。
源码分析：
1.类继承实现
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
{
//方法....
}
两个标记接口Cloneable，Serializable，可克隆，可序列化（在ArrayList篇已提到点击跳转Java集合源码实现一：ArrayList（jdk1.8））。
2.成员变量
/**
* 默认初始容量-必须是两个的幂。
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 如果一个更高的值被两个构造函数用参数隐式指定，那么将使用最大容量。
* 2^ 30 次方
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认加载因子。
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 转换成树的阈值
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 转换回链表的阈值
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 树的最小容量
* 至少应为4×treeify_threshold避免冲突
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 存储链表的数组
*/
transient Node<K,V>[] table;
/**
* 拥有缓存的entryset()
* keyset()和values()在AbstractMap 中声明
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 存储的元素数量
*/
transient int size;
/**
* 操作次数
*/
transient int modCount;
/**
* 扩容阈值 要调整大小的下一个size值（容量*负载因子）
* (capacity * load factor)
*/
int threshold;
/**
* 哈希表的加载因子。
*/
final float loadFactor;
3.HashMap中的链表节点
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;//哈希值
final K key;//key值
V value;//value值
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 K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
4.主要方法
构造方法
/**
* 使用默认初始容量（16）和默认加载因子（0.75）构造一个空的HashMap。
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // 所有其他字段默认
}
/**
* 使用指定的初始容量和默认加载因子（0.75）构造一个空的HashMap。
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 用指定的初始容量和加载因子构造一个空的HashMap。
*/
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;
//根据初始容量来计算扩容阈值
this.threshold = tableSizeFor(initialCapacity);
}
/**
* 使用与指定的Map相同的映射构造一个新的HashMap
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
hash算法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
将key的hashcode右移动16位，然后在于自身进行异或（^）操作，这样就变成自身的高16位与低16位进行异或，降低了hash碰撞率。
获取元素
/**
* 返回指定键值映射
*/
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* 实现了map.get和相关方法
*/
final Node<K,V> getNode(int hash, Object key) {
//指向table数组（存储链表的数组）
Node<K,V>[] tab;
//first：(n - 1) & hash处的第一个节点，（n-1）和hash相与就是node的位置
//e：为first的下一个节点
Node<K,V> first, e;
//n：数组的长度
int n;
//first的key值
K k;
//数组不为空，并且长度>0,并且该位置上有元素不为null
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//如果第一个节点的hash值相同和key值相同，第一个元素就是要查的元素直接返回first第一个节点
if (first.hash == hash && // 总是检查第一个节点
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//如果下一个节点不为null，进行遍历直到找到结果
if ((e = first.next) != null) {
//如果first是树结构，就去调用树方法去获取
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
//遍历到hash值相同和key值相同 进行返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
//都没有找到.....null
return null;
}
添加元素
/**
* 添加元素
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* 实现了map.put和相关方法
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
//指向table数组（存储链表的数组）
Node<K,V>[] tab;
// tab[i = (n - 1) & hash] 要添加的位置处的元素（这个表述不太准确）
Node<K,V> p;
int n, i;
//如果是个空的数组对table进行初始化扩容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果要添加的位置处没有元素，直接newNode,把新添加的元素放那
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//如果存在元素了 发送hash冲突了
Node<K,V> e; K k;
//如果新插入的元素与第一个节点的hash值相同和key值相同
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//将Node e指向到该位置的第一个元素
else if (p instanceof TreeNode)//如果是树结构的
//e指向 调用树添加的方法
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//则遍历链表进行查找替换 没找到就在尾部添加
for (int binCount = 0; ; ++binCount) {
//如果next为null 直到遍历完都没有找到相同的，直接添加到该链表最后面
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;
}
//如果新插入的元素与该节点的hash值相同和key值相同结束
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果e不为null，就是存在相同的，进行替换，并返回旧的value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);//为linkedHashMap服务的，hashmap中是个空方法，下一篇linkedHashMap篇中将会解释
return oldValue;
}
}
++modCount;//操作次数+1
//size超过阈值，扩容
if (++size > threshold)
resize();//扩容
afterNodeInsertion(evict);//为linkedHashMap服务的，hashmap中是个空方法，下一篇linkedHashMap篇中将会解释
return null;
}
扩容
/**
* 扩容方法
*/
final Node<K,V>[] resize() {
//扩容前数组
Node<K,V>[] oldTab = table;
//扩容前容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//旧的扩容阈值
int oldThr = threshold;
int newCap, newThr = 0;
//如果扩容前容量>0
if (oldCap > 0) {
//如果超过最大容量，阈值改为int最大值，直接返回不管了
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
}
//如果旧的容量为0并且阈值大于0，说明是空的hashmap刚初始化没有元素，当使用指定阈值的构造方法时会进入
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;//新的容量为旧的阈值
//使用无参构造方法HashMap()时会进入
else { // zero initial threshold signifies using defaults
//旧的容量和阈值都是0时，全部取默认值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的容量阈值为0，进行计算
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;
//如果旧的数组不为null，进行元素的转移
if (oldTab != null) {
//遍历旧数组
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果下一个节点为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);
//如果loTail 不为空 放在新表原来的位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//如果hiTail 不为空 放在（原索引+oldCap）位置
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
jdk1.8扩容方法相较于之前有较大的改动，定义两个链表分别维护，不会出现之前的多线程操作hashmap造成死循环的问题。但却会发生数据丢失问题，所以在并发情况下仍然要去考虑使用ConcurrentHashMap。
为什么扩容是2的次幂
原因： 当数组长度为2n的时候，出现hash碰撞的次数最少。
为保证hashmap存储空间能最大的利用，平均分配最好的方式是取模hash%length，但是在计算机中这种运算方式肯定没有位运算快，所以hashmap中是hash&(length-1)来确定位置，hash%length = hash&(length-1)，当length=2n的时候转换为二级制为10000…（1后面多个0），length-1=111111…（1后面多个1）， hash&(length-1)定位时，hash和length-1相与（&）运算（length-1是多个1），减少了碰撞。
与运算： 1&1=1 ； 1&0=0； 0&0=0；
移除元素
/**
* 如果存在，则从该映射移除指定键的映射
*/
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value;
}
/**
* 实现了map.remove和相关方法
* 其实原理上与上面的大致相同，就不做过多解释了
*/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
/**
* 清空所有键值对
*/
public void clear() {
Node<K,V>[] tab;
modCount++;//操作次数++
//如果不为null 直接循环全置null
if ((tab = table) != null && size > 0) {
size = 0;
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}