HashMap是Map集合下的常用子类,出现在JDK1.2,底层使用哈希表+红黑树实现。
之前我们在学习Set接口的时候,并没有深入研究过其代码,但当我们查看Set接口常用子类HashSet的源码时,会发现Set其实就是穿了马甲的Map:
private transient HashMap<E,Object> map;
private static final Object PRESENT = new Object();
public HashSet() {
map = new HashMap<>();
}
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
可见,在HashSet的内部有一个私有的HashMap对象,在调用构造方法时实例化此HashMap对象。再来看看其add(E e)方法:
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
可见,HashSet实际上是通过HashMap来存储元素的,只不过是将元素存储到了HashMap的key而已,而value都是共同的一个空的Object对象。
1.Set与Map的关系:
通过上面的分析我们不难得出,Set接口其实就是穿了马甲的Map接口,Set接口下的常用子类都是使用Map来存储元素的,将元素存储在Map的key中,而value是共同的空Object对象。
可见,学习Map接口下的常用子类,就相当于学习了Set接口下的常用子类。
所以,我们今天来看一看Map接口下的常用子类HashMap的源码:
2.HashMap源码的重要参数:
//初始化容量,即:桶的数量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//树化阈值
static final int TREEIFY_THRESHOLD = 8;
//解树化返回链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
//树化的最小元素个数
static final int MIN_TREEIFY_CAPACITY = 64;
//真正存储元素的哈希表
transient Node<K,V>[] table;
//扩容阈值:用来判断是否需要扩容
//也可以认为是真正存储元素的桶数量 = 负载因子 * 默认初始化桶数量
int threshold;
3.HashMap的构造方法:
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
可见,HashMap采用懒加载策略,在调用构造方法时并不会初始化哈希表,只会初始化负载因子。
4.HashMap的put(K key,V value):
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
可见,put方法实际上是先将我们的key值进行hash(),再调用putValue()方法:
hash()实际上是为了找到元素所在的桶的位置,(h>>>16)是无符号右移,相当于保留了高16位。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
//(h = key.hashCode()) ^ (h >>> 16)其实是为了让高低16位都参与异或运算,从而降低哈希冲突的概率
}
接下来,看一下putVal():
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//存储元素的哈希表
Node<K,V>[] tab;
//存放数据的节点
Node<K,V> p;
//n为哈希表的长度,i为元素在哈希表中的索引
int n, i;
//若当前哈希表为空,则进行哈希表的初始化操作
//(默认初始化为16个桶,实际上真正存储元素的桶数量threshold为12)
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//根据i=(n-1)&hash计算出元素在哈希表中存储的索引
//如果当前索引为空,没有元素,即未发生碰撞,则将该节点存放到哈希表中
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//此时说明发生了碰撞
else {
Node<K,V> e; K k;
//若节点处于同一个桶中,并且key值相同,则替换该节点
//可见,此处就实现了HashMap存储元素时,一个Key值只对应一个元素
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 {
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;
}
}
//若哈希表中存在key值相同的元素,则替换该元素的value值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//若桶数量>12,则进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
总结:
- 首先,判断哈希表是否为空,若为空,则为哈希表进行初始化,默认初始化容量为16。
- 根据hash()计算得到的桶位置,计算元素在哈希表中的索引,若当前索引位置没有元素,则将这个元素添加到索引处即可。
- 若当前位置有元素,并且key值相同,则替换该元素。
- 若此时已经树化,则调用树化的put()方法插入。
- 若此时还未树化,则封装为节点尾插入链表中。判断是否满足树化条件,若满足,树化插入;不满足,则往下走。
- 遍历链表,判断是否有key值相同的元素,若有,替换其value值。
- 插入成功后,判断当前桶数量是否大于12,若满足扩容条件则进行扩容。