HashMap学习
底层存储
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //用来定位数组索引位置
final K key;
V value;
Node<K,V> next; //链表的下一个node
Node(int hash, K key, V value, Node<K,V> next) { ... }
public final K getKey(){ ... }
public final V getValue() { ... }
public final String toString() { ... }
public final int hashCode() { ... }
public final V setValue(V newValue) { ... }
public final boolean equals(Object o) { ... }
}
- 在HashMap中table字段的每个位置上存储的就是上述一个个Node结点，或者多个结点形成的链表(此时table就记录了表头)。
- Node是真正存储了用户定义的Key、Value键值对,table和Node链表知识组织数据的方式
字段信息
java.util.HashMap#DEFAULT_INITIAL_CAPACITY
java.util.HashMap#DEFAULT_LOAD_FACTOR
java.util.HashMap#entrySet
java.util.HashMap#loadFactor
java.util.HashMap#MAXIMUM_CAPACITY
java.util.HashMap#MIN_TREEIFY_CAPACITY
java.util.HashMap#modCount
java.util.HashMap#size
java.util.HashMap#table
java.util.HashMap#threshold
java.util.HashMap#TREEIFY_THRESHOLD
java.util.HashMap#UNTREEIFY_THRESHOLD
hash运算
// 方法一：
static final int hash(Object key) { //jdk1.8 & jdk1.7
int h;
// h = key.hashCode() 为第一步 取hashCode值
// h ^ (h >>> 16) 为第二步 高位参与运算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
// 方法二：
static int indexFor(int h, int length) { //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
return h & (length-1); //第三步 取模运算
}
首先，Node[] table的初始化长度length(默认值是16)，Load factor为负载因子(默认值是0.75)，threshold是HashMap所能容纳的最大数据量的Node(键值对)个数。threshold = length * Load factor。也就是说，在数组定义好长度之后，负载因子越大，所能容纳的键值对个数越多。
结合负载因子的定义公式可知，threshold就是在此Load factor和length(数组长度)对应下允许的最大元素数目，超过这个数目就重新resize(扩容)，扩容后的HashMap容量是之前容量的两倍。默认的负载因子0.75是对空间和时间效率的一个平衡选择，建议大家不要修改，除非在时间和空间比较特殊的情况下，如果内存空间很多而又对时间效率要求很高，可以降低负载因子Load factor的值；相反，如果内存空间紧张而对时间效率要求不高，可以增加负载因子loadFactor的值，这个值可以大于1。
size这个字段其实很好理解，就是HashMap中实际存在的键值对数量。注意和table的长度length、容纳最大键值对数量threshold的区别。而modCount字段主要用来记录HashMap内部结构发生变化的次数，主要用于迭代的快速失败。强调一点，内部结构发生变化指的是结构发生变化，例如put新键值对，但是某个key对应的value值被覆盖不属于结构变化。
- 不管增加、删除、查找键值对，定位到哈希桶数组的位置都是很关键的第一步
- Hash算法本质上的三步：
- 取出key的hashCode值
- 高位运算
- 取模运算
- 两种不同实现
- 方法一
- 通过h & (table.length -1)来得到该对象的保存位，而HashMap底层数组的长度总是2的n次方，这是HashMap在速度上的优化。
- 当length总是2的n次方时，h& (length-1)运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。
- 方法二
- 在JDK1.8的实现中，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)
- 主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。
- 方法一
疑问
- 如果没有重写hashcode, 那么hashcode的值是什么？
- 是在堆中的地址嘛？不是，至少在jdk8中其实现方式如下
- OpenJDK8 默认hashCode的计算方法是通过和当前线程有关的一个随机数+三个确定值，
- 运用Marsaglia’s xorshift scheme随机数算法得到的一个随机数，
- 和对象内存地址无关
- 是在堆中的地址嘛？不是，至少在jdk8中其实现方式如下
- 一个类重写了equals方法，通常有必要重写hashcode，以维持常规定义，（相等的对象必须有相等的hashcode）保证
- equasl相同的两个对象，hashcode也要一致
- 但hashcode相同，不一定是同一个对象
- 为不相等的对象产生不同的hashcode可以提高哈希表的性能
初始化
-
使用HashMap <Key, String> map = new HashMap<>()进行初始化
-
只会初始化一个默认的负载因子，其值为0.75
-
table 没有被初始化
-
当你使用put()方法时，table才会被初始化，源码如下：
resize()函数
- 第一种情况，new HashMap<>()
-
DEFAULT_LOAD_FACTOR -> 0.75
-
DEFAULT_INITIAL_CAPACITY -> 16
-
threshold -> 12
-
局部变量newCap -> 16
-
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
-
返回 newTab；
- 在newTab之后，会判断旧的数组是否为空、
- 为空，直接返回
- 不为空，rehash
-
- 其余情况，下面源码分析，即可
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) { // 如果要resize的数组容量大于0，说明不是第一次进行resize
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab; // 如果已经最大了就不扩展了
}
// 容量进行两倍扩展，包括newCap和newThr，如果是第一次扩展，从16 12 ->32 24
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 { // 零初始化的地方，newcap = 16, newThr = 16*0.75;
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;
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) { // 遍历oldTab中的所有Node head
Node<K,V> e; // e备用
if ((e = oldTab[j]) != null) {
oldTab[j] = null;// 如果oldTab[j]不为空，取出node head到e之后，使其为空
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e; //如果该位置上只有一个node 直接rehash
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 { // 分成两段，上面一段，下面一段，因为对于同一个链表下的进行扩展之后
// 要对每一个结点进行重新映射，这是时候，可能会在原先的位置，也可能在j+oldCap的位置
next = e.next;
if ((e.hash & oldCap) == 0) { 哈希值与上 10000 如果不为零，那么说明其大于15 此时在16-31的位置中
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) { // 将链表头存储在newTab[j] 或者 newTab[j + oldCap]中
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
// 返回最小的大于cap的2的幂次数-1 如cap=10， return 15 如8 return 7
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;
}
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未被初始化执行resize()
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// (n - 1) & hash 取余操作 tab[i] 存入表头 首次存入 没有碰撞
// 在jdk1.7中有一个专门的方法来表示(n - 1) & hash
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
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 &&
// 哈希值一致时，引用相等，或者值相等都表示同一个key
// 在哈希值一致时，可能是同一个对象，也可能是不同对象
// 如果哈希一致，引用不相等，key不是同一对象，但可能是同一个key
// equals进行比较，以判断是不是同一个key
// 如果equasl相等，则是同一个key，此时在哈希表中进行覆盖
// 如果不相等，继续在该哈希值所对应的链表中继续查找，直到链尾或者中间遇到一致的
((k = e.key) == key || (key != null && key.equals(k))))
break; // 如果在链表中找到了hashcode相等，并且equals相等的 直接break
p = e;
}
}
if (e != null) { // existing mapping for key 存在
V oldValue = e.value; // 值进行替代，并将旧值返回
if (!onlyIfAbsent || oldValue == null) // onlyIfAbsent为默认为false，出现相同键值时，默认覆盖旧值
e.value = value;
// 跟LinkedHashMap有关
afterNodeAccess(e);
return oldValue; // 返回旧值
}
}
++modCount;
if (++size > threshold)
resize();
// 跟LinkedHashMap有关
afterNodeInsertion(evict);
return null;
}
treeifyBin()
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
/*
* 如果元素数组为空 或者 数组长度小于 树结构化的最小限制
* MIN_TREEIFY_CAPACITY 默认值64，对于这个值可以理解为：如果元素数组长度小于这个值，没有必要去进行结构转换
* 当一个数组位置上集中了多个键值对，那是因为这些key的hash值和数组长度取模之后结果相同。（并不是因为这些key的hash值相同）
* 因为hash值相同的概率不高，所以可以通过扩容的方式，来使得最终这些key的hash值在和新的数组长度取模之后，拆分到多个数组位置上。
*/
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize(); // 扩容
else if ((e = tab[index = (n - 1) & hash]) != null) { // 通过2的幂的取模运算定位在table中的位置
TreeNode<K,V> hd = null, tl = null; // 定义首尾结点
do {
TreeNode<K,V> p = replacementTreeNode(e, null);// 将该节点转换为 树节点
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null); // 结束构成成一个双向链表
if ((tab[index] = hd) != null) // 把转换后的双向链表替换成原来的单项链表
hd.treeify(tab); //实现该对象打头的链表转换为树结构
}
}
treeify()
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next;
x.left = x.right = null;
if (root == null) { // 构造红黑树根结点
x.parent = null;
x.red = false;
root = x;
}
else {
K k = x.key; // 当前结点的键值
int h = x.hash; // 当前结点的hash值 是没有mod过的hash
Class<?> kc = null; // 当前结点的类类型
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
if ((ph = p.hash) > h) // 比较大小
dir = -1; // 当前结点比较小，就放在左侧
else if (ph < h)
dir = 1; // 当前结点比较大，就放在右则
else if ((kc == null && // 如果相等进行再一次比较
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p; // 保存当前结点
// dir只能取-1 要么 1
// 如果p在更新之后不等null，p继续更新过子结点
// 如果p的子结点为空，说明到了插入的结点，根据此时的dir进行插入
// dir <=0就链接左则，大于0就链接在右则
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
// 进行平衡，可以根据2-3树进行理解，平衡会打乱root指向的结点
// 所以在构造完红黑树之后，需要进行moveRootToFront
root = balanceInsertion(root, x);
break;
}
}
}
}
// 找到根结点，因为此时还是为进行树构造之前的双向链表的头结点
moveRootToFront(tab, root);
}
moveRootToFront()
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
int n;
if (root != null && tab != null && (n = tab.length) > 0) { // 根结点不为空，并且HashMap的元素数组不为空
int index = (n - 1) & root.hash; // 根据根节点的Hash值 和 HashMap的元素数组长度 取得根节点在数组中的位置
TreeNode<K,V> first = (TreeNode<K,V>)tab[index]; // 首先取得该位置上的第一个节点对象
if (root != first) { // 如果该节点对象 与 根节点对象 不同 即在平衡的过程中root结点没有改变过
Node<K,V> rn; // 定义根节点的后一个节点
tab[index] = root; // 把元素数组index位置的元素替换为根节点对象
TreeNode<K,V> rp = root.prev; // 获取根节点对象的前一个节点
if ((rn = root.next) != null) // 如果root结点的下一个结点不为空
((TreeNode<K,V>)rn).prev = rp;
if (rp != null) // 如果root的前节点不为空
rp.next = rn; // root前节点的后节点 指向到 root的后节点
if (first != null) // 下面的代码，重新把root放到双向链表的首位置
first.prev = root;
root.next = first;
root.prev = null;
}
assert checkInvariants(root);
}
}
- 在这个TreeNode里面其实定义了两种结构：一种是红黑树结构，通过left和right链接
- 另一种是双向链表通过prev和next链接，通过treeify()函数是用left和right链接构造红黑树的。
- 在构造红黑树的过程中，会进行平衡，这会打乱root结点。所以需要通过moveRootToFront()函数进行root结点重新定位。
- 把root结点从双向链表中抽离出来，并不会影响红黑树的结构，所以查询是没问题的。
- first结点本来就是双向链表中的头结点，所以把root的next指向first，再把first的prev指向root，就重新把root加入双向链表了，也就成为了表头。
总结
- 初始容量和负载因子
- HashMap的一个实例有两个影响其性能的参数：初始容量和负载因子。
- 容量是哈希表中的桶数，初始容量只是创建哈希表时的容量。
- 加载因子是在自动增加容量之前，允许哈希表获取的完整程度的度量。
- 当哈希表中的条目数超过加载因子和当前容量的乘积时，哈希表将被重新哈希（即，重建内部数据结构），以便哈希表具有大约两倍的桶数
- 负载因子：
- 作为一般规则，默认负载因子（.75）在时间和空间成本之间提供了良好的权衡。
- 较高的值会减少空间开销，但会增加查找成本（反映在HashMap类的大多数操作中，包括get和put）。
- 在设置其初始容量时，应考虑映射中的预期条目数及其加载因子，以便最小化重新散列操作的数量。
- 如果初始容量大于实际的最大条目数除以加载因子，则不会发生重新加载操作。
- 同步
- HashMap实现不支持同步。
- 如果多个线程同时访问哈希映射，并且至少有一个线程在结构上修改了映射，则必须在外部进行同步。
- 结构修改是指添加或删除一个或多个映射的任何操作，仅更改与实例已包含的键关联的值不是结构修改。
- 使用Collections.synchronizedMap方法进行“包装”，以达到同步要求
- 这最好在创建时完成，以防止意外不同步访问
- 最快失败
- 所有这个类的“集合视图方法”返回的迭代器都是快速失败的
- 如果在创建迭代器之后的任何时候对映射进行结构修改，除了通过迭代器自己的remove方法之外，迭代器将抛出ConcurrentModificationException。
- 因此，在并发修改的情况下，迭代器快速而干净地失败，而不是在未来的未确定时间冒着任意的，非确定性行为的风险。
- 不能依赖于快速失败
- 请注意，迭代器的快速失败行为无法得到保证
- 因为一般来说，在存在不同步的并发修改时，不可能做出任何硬性保证。
- 失败快速迭代器会尽最大努力抛出 ConcurrentModificationException
- 因此，编写依赖于此异常的程序以确保其正确性是错误的：迭代器的快速失败行为应该仅用于检测错误。
- 拉链过长
- 即使负载因子和Hash算法设计的再合理，也免不了会出现拉链过长的情况
- 一旦出现拉链过长，则会严重影响HashMap的性能
- JDK1.8版本中，对数据结构做了进一步的优化，引入了红黑树
- 而当链表长度太长（默认超过8）时，链表就转换为红黑树，利用红黑树快速增删改查的特点提高HashMap的性能
- 其中会用到红黑树的插入、删除、查找等算法。
706
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
