本文详细分析了HashMap的源码，包括参数列表、内部Node节点、哈希函数、容量适配函数、构造函数、get、containsKey和put等关键方法。特别探讨了为何HashMap的初始容量设置为16，主要原因是方便Hash运算和优化扩容策略，以减少哈希冲突并提高性能。
一、关于源码：
1、参数列表
// HashMap默认容量，采用位运算，运算速度更快
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// HashMap的默认最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 链表转为红黑树的条件
// 1.链表的长度>=8
// 2.数组的长度>=64 所以链表要变为红黑树，最少需要进行两次扩容resize()16->32->64
static final int TREEIFY_THRESHOLD = 8;
// 反树化：如果红黑树上的节点<=6，那就将红黑树转回链表
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
源码解析 ：
- DEFAULT_INITIAL_CAPACITY：HashMap默认容量2^4 ->16，采用位运算，运算速度更快
- MAXIMUM_CAPACITY：HashMap的默认最大容量
- DEFAULT_LOAD_FACTOR：默认负载因子，当数组容量达到最大值的0.75时进行扩容
- TREEIFY_THRESHOLD：树化：当桶中链表的长度达到8时并且MIN_TREEIFY_CAPACITY（树化需要达到的最小桶个数）达到64时进行树化
- UNTREEIFY_THRESHOLD： 反树化，如果红黑树上的节点<=6就将红黑树转回链表
- MIN_TREEIFY_CAPACITY：树化需要达到的最小桶个数
2、内部静态类：Node节点
static class Node<K,V> implements Map.Entry<K,V> {
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;
return o instanceof Map.Entry<?, ?> e
&& Objects.equals(key, e.getKey())
&& Objects.equals(value, e.getValue());
}
}
源码解析 ：
实现了链表的基本操作
3、哈希函数（散列函数）
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
源码解析 ：
可以将源码改写为以下代码更方便理解
static final int hash(Object key) {
int h;
int temp;
if (key == null) {
return 0;
}else {
h = key.hashCode();
temp = h >>> 16;
return h ^ temp;
}
}
思路 ：
- 判断key是否为空，如果为空就返回0值
- 否则获得一个key对应的hashCode值，这是一个32位的二进制数。但是由于后面进行索引确定的时候，
是使用 hash(key) & n -1（哈希值 & 数组容量-1），然后对于默认数组容量为16，n-1对应的二进制为后四位，其他位都为0，这时候与一个16位的哈希值相与，就是出现结果只取决于后四位的情况，这样不同的key所对应的索引更有可能是相同的，更容易发生哈希冲突。所以这里的hash函数采用h >>> 16 右移16位的操作，使得高16位的数据参与运算，增加索引的范围。 - 这里通过将高16位的数据与低16位的数据进行异或操作，这是因为相比与运算和或运算，异或运算获得0和1的概率都为50%。
4、（后续了解）
static Class<?> comparableClassFor(Object x) {
if (x instanceof Comparable) {
Class<?> c; Type[] ts, as; ParameterizedType p;
if ((c = x.getClass()) == String.class) // bypass checks
return c;
if ((ts = c.getGenericInterfaces()) != null) {
for (Type t : ts) {
if ((t instanceof ParameterizedType) &&
((p = (ParameterizedType) t).getRawType() ==
Comparable.class) &&
(as = p.getActualTypeArguments()) != null &&
as.length == 1 && as[0] == c) // type arg is c
return c;
}
}
}
return null;
}
源码解析 ：
5、（后续了解）
static int compareComparables(Class<?> kc, Object k, Object x) {
return (x == null || x.getClass() != kc ? 0 :
((Comparable)k).compareTo(x));
}
源码解析 ：
6、传入数组容量的适配函数
static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
源码解析 ：
tableSizeFor的核心就是判断cap是否合理，既是2的幂次方，且不超过MAXIMUM_CAPACITY。如果不是2的幂次方，那么会不断通过位运算，将原cap的位置1，最后+1，得到一个2的幂次方的偶数
7、相关参数
transient Node<K,V>[] table;
transient Set<Map.Entry<K,V>> entrySet;
transient int size;
transient int modCount;
int threshold;
final float loadFactor;
源码解析 ：
- table：数组的定义
- entrySet：保存缓存的entrySet()
- size：该映射中包含的键值对映射数
- modCount：哈希表在结构上被修改的次数
- threshold：要调整大小的下一个size值（容量*负载因子）。
- loadFactor：哈希表的负载因子
注意： table是在每次使用的时候进行初始化，并且长度必须为2的整数幂
原因
- 为了方便 Hash运算
如果不使用二次幂那在使用与运算 的时候，例如 hash & (x-1) ，x不是2的整数幂，那就会导致hash与的值不是一个1111这种类型的数据 - 为了更好地扩容
默认是16位的大小，数组的下标为hash%16 或者 hash & (16-1)，获得一个低四位的值
而使用resize()进行扩容之后，会将数组长度变为32，数组的下标为hash%32 或者 hash & (32-1
）这样的结果和扩容前相比就是在第五位上会有0和1的区别，例如原来的数组长度为16的时候，key对应的hash=4或者20的时候，低四位为都是 hash & (16-1)的结果0100，那个将数组扩容之后，hash & (32-1）的结果为4:00100,然而20:10100，这样扩容前4和20对应的都是索引为4的位置，但是扩容之后4和20对应的索引位置就分别是4和20。所以每次扩容只会影响当前哈希值的前面一位，这样扩容之后只会出现在两个位置，减少扩容的可能性。
8、HashMap()的构造函数
/**
* 根据给定的初始容量的装载因子创建一个空的HashMap
* 初始容量小于0或装载因子小于等于0将报异常
* tableSizeFor()是一个算法，能够返回一个比给定数大且最接近2的幂次方的整数
*/
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);
}
// 根据指定容量创建一个空的HashMap
// 调用上面的构造方法，容量为指定的容量，负载因子是默认值
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
// 通过传入的map创建一个HashMap
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
9、（后续了解）
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
} else {
while (s > threshold && table.length < MAXIMUM_CAPACITY)
resize();
}
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
源码解析 ：
- m：对应的数组
10、获得集合的大小
public int size() {
return size;
}
11、判断是否为空集合
public boolean isEmpty() {
return size == 0;
}
12、get函数；返回对应key的value
public V get(Object key) {
Node<K,V> e;
return (e = getNode(key)) == null ? null : e.value;
}
源码解析 ：
通过Key获取Value，本质是通过getNode方法获取
13、getNode函数
final Node<K,V> getNode(Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n, hash; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & (hash = hash(key))]) != 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;
}
目的： 通过hash和key获取对应的Node节点，返回Node节点
源码解析 ：
- 首先需要数组不为空、数组长度>0,、key对应的索引所指向的值不为空才能执行后续语句，否则return null；
tab[(n - 1) & (hash = hash(key))] 其实就是前面提到的根据key的hash值来计算得出这个key放在了hash桶数组的哪个位置上。
first保存的是链表的头结点 - 如果链表头节点的hash等于传入的hash、首节点的key的地址等于参数key或者参数key不为null且值与首节点key相同说明头结点就是要找的节点，将头结点返回。
- 如果头结点不为空
如果首节点是树形节点，则通过getTreeNode方法去查找(红黑树结构)
如果不是树形节点，遍历链表，直到找到hash、key都相同，返回当前节点
14、containsKey函数
public boolean containsKey(Object key) {
return getNode(key) != null;
}
目的： 判断HashMap中是否有该key
15、put函数
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
目的： 调用putVal()函数，为集合插入一个key-value元素
源码解析 ：
- 如果存在同一的key,则更新Value，因为传入putVal的参数onlyIfAbsent为false
16、putValue函数
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为null或者长度为0，就进行初始化操作
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 如果table所在位置还没有元素，就将newNode放在这个位置
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 表明对应位置已经有节点了 也就是发生了哈希冲突，判断使用红黑树还是链表
else {
Node<K,V> e; K k;
// 判断哈希值与传入哈希值是否相同 key不为空且相同
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果是红黑树结构，就调用putTreeVal方法
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 不是红黑树结构 使用链表操作
else {
// 遍历链表
for (int binCount = 0; ; ++binCount) {
// 临时节点每次指向p节点的下一个，如果到链表末尾就添加newNode
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 如果循环的次数>=8，即链表长度大于等于8时
// 执行链表转换成红黑树结构的方法
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 如果链表中已存在这个key，则退出for循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 更新遍历的位置
p = e;
}
}
// 在桶中已经存在对应的key
// 在前面寻找尾节点的过程中，如果发现相同key，会执行break，结束for循环，这时候e肯定不为空，进行对旧值的更新
// 如果成功在末尾添加了元素 那么(e = p.next) == null
if (e != null) { // existing mapping for key
V oldValue = e.value;
// 如果onlyIfAbsent为false或oldV为null，这里的onlyIfAbsent设置为false就表示需要用新值更新旧值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 哈希表在结构上被修改的次数，如果是尾插法成功插入就++，但是如果是更新旧值则会return oldValue;不会实现++
++modCount;
// 如果集合容量大于临界值，则扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
目的： 为集合插入key-value元素
注意： 哈希表中的数组初始化是在调用putValue()方法的时候才会进行初始化，并不是一开始就进行初始化。
源码解析 ：
- 如果是链表通过尾插法插入元素，如果是红黑树调用putTreeVal方法
- 如果key相同，新value会覆盖旧value，且返回旧value
17、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
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;
}
目的： 将table初始化或者将table长度翻倍
源码解析：
HashMap源码相关问题
1、为什么初始容量DEFAULT_INITIAL_CAPACITY设置为16？
选取2的整数次幂为了更好地散列？ 并不是这个原因，因为我们在进行散列函数里面的散列计算方法是除法散列法，就是让key除以一个数m取余数，这样key就能够被映射到m个槽位中的一个，散列函数是：
h(key) = key mod m;
但是在选取m时应该避免选取2的整数幂，因为如果m=2^p，那么h(k)就是key的p个最低位数字。除非知道各种最低p位的排列是等可能的，所以尽量避免选择2的整数幂，选择一个不太接近2的整数幂的素数是最好的选择。
答案：
1.为了方便 Hash运算
2. 为了更好地扩容
默认是16位的大小，数组的下标为hash%16 或者 hash & (16-1)，获得一个低四位的值
而使用resize()进行扩容之后，会将数组长度变为32，数组的下标为hash%32 或者 hash & (32-1
）这样的结果和扩容前相比就是在第五位上会有0和1的区别，例如原来的数组长度为16的时候，key对应的hash=4或者20的时候，低四位为都是 hash & (16-1)的结果0100，那个将数组扩容之后，hash & (32-1）的结果为4:00100,然而20:10100，这样扩容前4和20对应的都是索引为4的位置，但是扩容之后4和20对应的索引位置就分别是4和20。所以每次扩容只会影响当前哈希值的前面一位，这样扩容之后只会出现在两个位置，减少扩容的可能性。
如果不使用二次幂那在使用与运算 的时候，例如 hash & (x-1) ，x不是2的整数幂，那就会导致hash与的值不是一个1111这种类型的数据
扫一扫
1593
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
