源码分析
基于JDK1.8
4个构造函数
HashMap()
//1. 无参构造
/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
//构造一个空的HashMap,初始容量为16，负载因子是0.75
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
//负载因子默认为0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
负载因子，代表了table的填充度有多少，默认是0.75 加载因子存在的原因，还是因为减缓哈希冲突，如果初始桶为16，等到满16个元素才扩容，某些桶里可能就有不止一个元素了。 所以加载因子默认为0.75，也就是说大小为16的HashMap，到了第13个元素，就会扩容成32。
HashMap(int initialCapacity)
//创建一个初始容量为initialCapacity，负载因子为0.75的HashMap
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
HashMap(int initialCapacity, float loadFactor)
//构造一个空的初始容量为initialCapacity，负载因子为loadFactor的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);
}
//最大容量（1 << 30 也就是2的30次方）
static final int MAXIMUM_CAPACITY = 1 << 30;
这里为什么是2的30次方，请看这篇博客！
设定threshold。这个threshold=capacity * loadFactor。当HaspMap的size到了threshold，就会进行resize,也就是扩容。
tableSizeFor()的主要功能是返回一个比给定整数大且最接近2的幂次方整数，如给定10，返回2的4次方16。
找到tableSizeFor(int cap)的源码：
/**
* Returns a power of two size for the given target capacity.
*/
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;
}
根据上面给的那个如cap为10。看一下运算过程！
HashMap(Map<? extends K, ? extends V> m)
//构造一个和制定Map有相同mappings的HashMap，初始容量能充足的容下指定的Map,负载因子为0.75
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
直接看putMapEntries(m, false)。源码如下：
//将m的所有元素存入本HashMap实例中
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//得到m中的元素个数
int s = m.size();
//当m中有元素时，则需要将map中元素放入本HashMap实例
if (s > 0) {
//判断table是否已初始化，如果未初始化，则先初始化一些变量。（table初始化是在put时）
if (table == null) { // pre-size
//根据待插入的map的size计算要创建的 HashMap 的容量
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
//把要创建的HashMap 的容量存在 threshold中
if (t > threshold)
threshold = tableSizeFor(t);
}
//进行扩容
else if (s > threshold)
resize();
//然后就开始遍历 插入的map，将每一个<key, value>插入到本HashMap实例中
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
//put(K,V)也是调用putVal 方法进行元素的插入
putVal(hash(key), key, value, false, evict);
}
}
}
putMapEntries方法中，如果table为null，那么这时就设置合适的threshold，如果不为空并且指定的map的size > threshold，那么就resize()，然后把指定的map中的所有key,value，通过putVal添加到我们创建的新的map中。
那咱们先看一下hash(key)。
/**
* key 的hash值的计算是通过hashcode()的高16位与低16位做异或实现的：
* (h = key.hashCode()) ^ (h >>> 16)
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
public native int hashCode();
异或运算：(h = key.hashCode()) ^ (h >>> 16)
原来的hashcode: 1111 1111 1111 1111 0100 1100 0000 1010
移位后的hashcode: 0000 0000 0000 0000 1111 1111 1111 1111
进行异或运算 结果： 1111 11111 1111 1111 1011 0011 1111 0101
这样做的好处是：可以将hashcode高位和低位的值进行混合做异或运算，而且混合后，低位的信息中加入了高位的信息，这样高位的信息被变相的保留了下来。参杂的元素多了，那么生成的hash值的随机性会增大。
再来看一下resize() 方法。
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the table
*/
final Node<K,V>[] resize() {
//保存当前table
Node<K,V>[] oldTab = table;
//保存当前table的容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//保存当前阈值
int oldThr = threshold;
//初始化新的table容量和阈值
int newCap, newThr = 0;
/*
1. resize() 方法在size > threshold时被调用。oldCap大于0 代表原来的table非空，
oldCap为原表的大小， oldThr（threshold）为 oldCap * load_factor
*/
if (oldCap > 0) {
//若旧table容量已超过最大容量，更新阈值为Integer.MAX_VALUE，这样以后不会自动扩容了
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
}
/*
2. resize() 函数在table为空被调用。oldCap 小于等于0且oldThr 大于0，代表用户
创建了一个HashMap。但是使用的构造函数为HashMap(int initialCapacity) 或
HashMap(int initialCapacity, float loadFactor) 或 HashMap(Map<? extends K, ? extends V> m)，导致oldTab为null，oldCap为0，oldThr为用户指定的HashMap的初始容量
*/
else if (oldThr > 0) // initial capacity was placed in threshold
//当table没初始化时，threshold持有初始容量。
newCap = oldThr;
/*
3. resize()函数在table为空被调用。oldCap 小于等于0且oldThr 等于0。
用户调用HashMap()构造函数创建的HashMap，所有值均采用默认值，oldTab(Table)为空，oldCap为0，oldThr为0
*/
else { // zero initial threshold signifies using defaults
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"})
//初始化table
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//把oldTab中的节点，reHash 到newTab中去
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//若节点是单节点，直接在newTab中进行重定位
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//若节点是TreeNode节点，要进行红黑树的rehash操作
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//若是链表，进行链表的rehash操作
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//将同一桶中的元素根据(e.hash & oldCap)是否为0进行分割
do {
next = e.next;
//根据算法，(e.hash & oldCap) 判断节点位置rehash后是否发生改变
//最高位==0，这是索引不变的链表
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//最高位为1，这是索引发生改变的链表
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;
//rehash 后节点新的位置一定为原来基础上加上oldCap
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
这里使用的是2次幂的扩展，指长度扩为原来的2倍。所以，元素的位置要么是在原来的位置，要么是在原本位置上再移动2次幂的位置。
如下图，n 为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。
这里加一一个方法，在jdk1.7里面有，1.8中没有，但是实现原理是一样的。
static int indexFor(int h, int length) { //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
return h & (length-1);
}
确定索引位置的例子你就能看懂了。
key的hash值与n-1做& 运算。
元素在重新计算hash之后，因为n变为2倍，那么n-1 的mask范围在高位多1bit（红色）。因此新的index会发生这样的变化:
因此，在扩充HashMap的时候，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引就变为”原来的索引+ oldCap“ 。
什么时候扩容：通过上述源码可以看到是在put操作时，即向容器中添加元素时，判断当前容器中的元素的个数是否达到阈值的时候，就要自动扩容了。
再最后看一下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;
//如果table为空或者长度为0，则resize()
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//确定插入table的位置，算法是(n - 1) & hash，在n为2的幂时，相当于取模操作
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//在table的i位置发生碰撞，有两种情况：
//1. key一样，替换value
//2. key不一样，有两种处理方法：存储在i位置的链表中，存储在红黑树中
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 {
//不是TreeNode，即为链表，遍历链表
for (int binCount = 0; ; ++binCount) {
//链表的尾端也没有找到key值相同的节点，则生成一个新的node
//并且判断链表的节点个数是不是到达转换成红黑树的上界，到达则转换红黑树
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;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
static final int TREEIFY_THRESHOLD = 8;
附：
参考： https://www.jianshu.com/p/ee0de4c99f87
最后一张图： https://blog.csdn.net/woshimaxiao1/article/details/83661464
扫一扫
3008
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
