简介
Hashmap是Java中常用的一种集合，文章简单对其源码做了一些简单刨析基于JDK8；
HashMap中的初始化参数：
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
//指定序列号，用于序列化
private static final long serialVersionUID = 362498820763181265L;
/**
* 默认初始化的容量16，理由是减少扩容带来的损耗；
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
最大容量，在两个带参数的构造函数隐式指定更高值时使用。 必须是 2 的幂 <= 1<<30。
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认扩容阈值，当达到0.75时扩容；
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 转化节点，链表长度大于8时，作为转化红黑树的条件；理由时此时的hash重装概率最低，
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 转化节点数，红黑树节点小于6时转回链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 数组长度大于64时与上述链表节点8组合，此时转化红黑树；
* 应至少为 4 * TREEIFY_THRESHOLD，以避免调整大小和树化阈值之间发生冲突。
*/
static final int MIN_TREEIFY_CAPACITY = 64;
存储节点结构
HashMap中的存储类型，数组中的每个节点样式；包括key、value和next三个字段量，是一种Entry结构。用传入key的二次hash存入key，传入value作为值存储再value中；使用next指向hash冲突的其他对象；
static class Node<K,V> implements Map.Entry<K,V> {
//数组中的每个节点样式；包括key、value和next三个字段量
final int hash;
final K key;
V 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;
}
}
key值的hash算法
HashMap中对于key的二次hash算法，即将hashcode再进行右移16为操作得到结果；原因推断是表中的数据由二进制存储，通过向较低位传播，使得数据较高位的影响变低，简而言之就是为了减少hash冲突；
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
构造方法
首先有一些临时参数：用于表内处理,源码中有一个transient关键字，标记了操作时用到的一些短暂变量，这些变量主要是用于表的结构操作，而且改关键字表示后的变量不会序列化到持久化对象中；
/**
*存储表节点的数组；
*/
transient Node<K,V>[] table;
/**
* 用于遍历的，记录了键值对数量；
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 表中的数据量
*/
transient int size;
/**
* 记录表结构修改次数，比如用于再使用迭代器时的异常，即不能改值；
*/
transient int modCount;
/**
*临时扩容的下一个大小值；是2的幂；
*/
int threshold;
/**
*负载因子
*/
final float loadFactor;
除了最后一个，其他不会初始化表结构；
//带初始化容量和加载因子的
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);
}
//初始化参数大小的
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
//主要用于传入一个已有的集合
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
//这个方法会初始化一个大于m容量的2的幂大小的hashmap；
putMapEntries(m, false);
}
存值
整体的存值需要做的事是将传入的key和value转化成节点，并存入链表中；
HashMap对于key是计算位置的公式：(表长度-1)&key的二次hash值；
计算出位置之后进行位置冲突判断，冲突了即当前位置有存储其他key才会进行key值比对，判断覆盖值或接在后边作为next的节点存储。不冲突之间在当前位置插入新节点；
public V put(K key, V value) {
//此处的hash是上面的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;
//是否需要初始化，这里table是上边说的表的node数组；
if ((tab = table) == null || (n = tab.length) == 0)
//resize方法是用于初始化或者扩容
n = (tab = resize()).length;
//这里通过表总长度-1与hash值计算其在数组中的位置；
//如果当前位置没有，就新建节点，
if ((p = tab[i = (n - 1) & hash]) == null){
tab[i] = newNode(hash, key, value, null);
}else {
//如果当前节点位置有值，判断是否需要覆盖值；
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//key值不同，出现hash冲突，接在链表或树结构下的新节点；
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);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//进行值的覆盖；
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//记录了修改次数并判断是否需要扩容；
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
取值
取值操作，除了常规的判错，就是通过key计算位置取值的操作；
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash &&
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
扩容
扩容长度限制，在第一次使用时初始化，并根据需要调整大小。 分配时，长度始终是 2 的幂；
扩容时的长度计算如下：对传入的临界扩容之进行计算使其始终为2的幂；
static final int tableSizeFor(int cap) {
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;
}
具体机制：当扩容达到负载因子0.75*表容量时；进行扩容操作，
扩容首先是数据的拷贝、然后新建更大的数组、然后将原数据进行拷贝；
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//判断初始化或者是扩容操作oladcap
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
}
//oldThr将赋值的下一个长度
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)
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;
}
源码中的实现说明翻译，bin指普通链表上的节点；
···
* 实施说明。
*
* 此映射通常充当分箱（桶）哈希表，但
* 当 bins 变得太大时，它们被转换成
* TreeNodes，每个结构类似于
* java.util.TreeMap。大多数方法都尝试使用普通的 bins，但是
* 在适用时中继到 TreeNode 方法（只需检查
* 节点的实例）。可以遍历 TreeNode 的 bins 并且
* 像任何其他人一样使用，但另外支持更快的查找
* 当人口过多时。然而，由于绝大多数垃圾箱
* 正常使用不会过多，检查是否存在
* 树箱可能会在表格方法的过程中延迟。
*
* 树箱（即元素都是 TreeNodes 的箱）是
* 主要按 hashCode 排序，但在平局的情况下，如果两个
* 元素具有相同的“C 类实现 Comparable<C>”，
* type 然后他们的 compareTo 方法用于排序。 （我们
* 通过反射保守地检查泛型类型以进行验证
* 这个——见方法可比较ClassFor）。增加的复杂性
* 树箱在提供最坏情况 O(log n) 方面是值得的
* 当键具有不同的哈希值或具有不同的哈希值时的操作
* 可订购，因此，性能在
* 意外或恶意使用 hashCode() 方法
* 返回分布不均的值，以及
* 许多键共享一个哈希码，只要它们也是
* 可比。 （如果这些都不适用，我们可能会浪费大约
* 与不考虑相比，时间和空间的两倍
* 预防措施。但唯一已知的案例源于糟糕的用户
* 已经很慢的编程实践，这使得
* 差别不大。）
*
* 因为 TreeNodes 的大小大约是常规节点的两倍，我们
* 仅当 bin 包含足够的节点以保证使用时才使用它们
*（见 TREEIFY_THRESHOLD）。当它们变得太小（由于
* 移除或调整大小）它们被转换回普通垃圾箱。在
* 使用分布良好的用户哈希码，树箱是
* 很少使用。理想情况下，在随机 hashCodes 下，
* bins 中的节点服从泊松分布
* (http://en.wikipedia.org/wiki/Poisson_distribution) 与
* 默认调整大小的参数平均约为 0.5
* 0.75 的阈值，虽然有很大的差异，因为
* 调整粒度。忽略方差，预期
* 列表大小 k 的出现次数为 (exp(-0.5) * pow(0.5, k) /
*阶乘（k））。第一个值是：
*
* 0：0.60653066
* 1：0.30326533
* 2：0.07581633
* 3：0.01263606
* 4：0.00157952
* 5：0.00015795
* 6：0.00001316
* 7：0.00000094
* 8：0.00000006
* 更多：少于千万分之一
*
* 一个树 bin 的根通常是它的第一个节点。然而，
* 有时（目前仅在 Iterator.remove 上），根可能
* 在别处，但可以通过父链接恢复
*（方法 TreeNode.root()）。
*
* 所有适用的内部方法都接受一个哈希码作为
* 参数（通常由公共方法提供），允许
* 他们在不重新计算用户哈希码的情况下互相调用。
* 大多数内部方法也接受“tab”参数，即
* 通常是当前表，但可能是新表或旧表
* 调整大小或转换。
*
* 当 bin 列表被树化、分裂或未树化时，我们保持
* 它们以相同的相对访问/遍历顺序（即字段
* Node.next) 更好地保留局部性，并稍微
* 简化对调用的拆分和遍历的处理
* 迭代器.remove。在插入时使用比较器时，要保持
* 总订购量（或尽可能接近此处的要求）
* 重新平衡，我们将类和 identityHashCodes 比较为
* 决胜局。
*
* 普通模式与树模式之间的使用和转换是
* 由于子类 LinkedHashMap 的存在而复杂化。看
* 下面是定义为在插入时调用的钩子方法，
* 允许 LinkedHashMap 内部的删除和访问
* 否则保持独立于这些机制。 （这也是
* 要求将地图实例传递给某些实用程序方法
* 可能会创建新节点。）
*
* 类似并发编程的基于 SSA 的编码风格有助于
* 避免在所有扭曲的指针操作中出现混叠错误。
···