Android学习之路（四）——HashMap源码
在此介绍Java8的hashmap，Java7的结构不一样
Java8中HashMap是由数组、链表、红黑树组成，这里由于自己对红黑树了解不多，没有解析红黑树的代码。
这里也只查看了查找get以及填充put的代码
1.1 HashMap存储的数据结构
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
/**
* hash : key 的哈希值
* key : 键
* value : 值
* next : 下一个节点
*/
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
1.2 示例
public class Demo {
public static void main(String[] args) {
HashMap<String, String> stringStringHashMap = new HashMap<>();
String put = stringStringHashMap.put("s", "s");
stringStringHashMap.get("s");
}
}
1.3 构造函数，无参
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
1.4 put 流程
可以看出在初始化时没有创建一个数组，只是确定了哈希表的负载因子为0.75（负载因子 = 表中元素个数 / 散列表长度。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
1.4.1 查看putVal（）函数
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 1、判断表是否为null，以及表长度为0，为空则创建表
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 填充的位置为空直接创建一个新节点填入
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;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 链表记录数据，当填充到链表里后，元素数量小于8，直接使用尾插法填入，大于8时，链表变成红黑树。
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// TREEIFY_THRESHOLD = 8,当填入数大于8时会重置为树
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相同，则将新值替换旧值，返回旧值，null也会返回
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//hashmap的子类实现方法这里不管
afterNodeAccess(e);
return oldValue;
}
}
// 由于hashmaop线程不安全，在这里使用modCount记录修改次数。
++modCount;
// 当填入后大于预设值，负载因子*表的长度，扩展表
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
1.4.2 resize 初始创建&扩展
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
// 给链表设置默认长度 DEFAULT_INITIAL_CAPACITY = 1<<4 (16)
// 设置哈希表的预设值 DEFAULT_LOAD_FACTOR = 0.75f
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
// 下面的代码就是进行链表的元素添加进新创建的表里面
// 这里的四个参数，是对两个链表进行添加的操作，分别是高位链表，和低位链表
// 上面扩容的时候是直接扩容的两位，以及获取新的定位值时是hash值取余，
// 所以新的定位值只会出现在 x 与 x + oldCap的位置上
// loHead loTail 处理 x 位置上的链表
// hiHead hiTail 处理 x+oldCap 位置上的链表
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.4.3 treeifyBin
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// MIN_TREEIFY_CAPACITY = 64
// 判断数组长度是否为低于64，高于64才进行树化，低于64进行数组扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
}
1.5 get
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
1.5.1 getNode 获取节点
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 数组不为null 数组长度不为空 桶（链表）内有数据
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 检查第一个节点
if (first.hash == hash && // always check first node
((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;
}
1.6 总结
1.6.1 put流程
- 在new的时候不会创建数组，会在第一次使用put的时候，在resize将设置数组的初始值，预设值
- 初始值容量16，加载因子0.75，(
DEFAULT_INITIAL_CAPACITY = 1 << 4,DEFAULT_LOAD_FACTOR = 0.75f)，因此排除初试化自己设置容器和传入Map类型，在12时就会扩容哈希表，在resize()方法扩，是将容量，预设值扩容双倍（除一些情况外：如容器大于最大值1<<30）。 - 定位填充位置，如果填充位置无值，直接填充进入，有值则，是否key一样，key一样则替换旧值，并返回旧值
- 判断是否是树节点，是进树查找填充
- 如果不是树节点，遍历链表查找，链表中有一样的key 替换旧值，并返回旧值，没有则尾插法插进链表中，但是当填充到该链表大于8并且哈希表容量到达64就会将链表树化。
- 返回值都是填充位置的旧值，
null也会返回。
1.6.2 get流程
- 先判断数组为null、长度为0直接返回null
- 检查位置的第一个节点，key一样直接返回
- 搜索树，以及链表值
1.7 其中包含了一些优秀的计算方式
1.7.1 (n - 1) & hash
是一种常见的位运算表达式，通常用于哈希表（hash table）或位图（bitmap）等数据结构。这里的 & 是按位与（bitwise AND）运算符，hash 是一个哈希值，而 n 通常是哈希表的大小或者位图的大小。
这个表达式的主要目的是将哈希值 hash 转换为一个在 0 到 n - 1 范围内的索引。通过使用按位与运算，这种转换通常比取模运算（hash % n）更快，尤其是当 n 是 2 的幂时。
为什么这样做有效，尤其是当 n 是 2 的幂时？
假设 n 是 2 的某个幂，比如 n = 2^k。在二进制表示中，n - 1 的所有低位都是 1，而高位都是 0。例如，如果 n = 16（即 2^4），则 n - 1 = 15，其二进制表示为 1111。
当我们将 hash 与 n - 1 进行按位与运算时，hash 的高于 n - 1 的所有位的部分都会被清零，而低位则保持不变。这确保了结果是一个小于 n 的数。
举个例子：
假设 hash = 22，其二进制表示为 10110，而 n = 16（n - 1 = 15，二进制为 1111）。
进行按位与运算：
hash : 0001 0110
n - 1 : 0000 1111
result: 0001 0110
结果是 10110，它等于十进制中的 22，这仍然是一个有效的索引（在这个例子中，它没有变化，因为 22 已经小于 16）。但如果 hash 是一个更大的数，比如 30（二进制 11110），按位与运算会将其转换为 14（二进制 1110），这是一个有效的索引值，小于 n。
这种方法比使用取模运算更快，因为大多数现代处理器可以非常高效地执行按位与运算。此外，当 n 不是 2 的幂时，这种方法可能不适用，因为它不会均匀地分布哈希值。因此，在实践中，通常会选择 n 为 2 的幂来优化性能并确保哈希值的均匀分布。
1.7.2 (h = key.hashCode()) ^ (h >>> 16)
这个表达式在 Java 的 HashMap 类中经常用来进一步混合哈希码，以确保键值的均匀分布，特别是在较小的表格（即较小的数组）中。
这个操作的主要目的是进一步混淆哈希码，使得哈希码的不同部分能够影响最终的结果。特别是当哈希表的大小较小，并且哈希码的不同高位被忽略时，这种混淆是非常有用的。通过右移 16 位并异或，高位的信息会以一种非线性的方式混入低位，增加了最终哈希值的随机性和分布均匀性。
在 HashMap 的实现中，这种操作有助于减少哈希冲突，即不同的键映射到哈希表中的同一个位置的情况，从而提高了性能。
3467
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
