HashMap源码解读

1.看源码之前需要了解的一些内容

Node<K,V>[] table 哈希表结构中数组的名字

DEFAULT_INITIAL_CAPACITY： 数组默认长度16

DEFAULT_LOAD_FACTOR： 默认加载因子0.75

HashMap里面每一个对象包含以下内容：

1.1 链表中的键值对对象

包含：

int hash; //键的哈希值

final K key; //键

V value; //值

Node<K,V> next; //下一个节点的地址值

1.2 红黑树中的键值对对象

包含：

int hash; //键的哈希值

final K key; //键

V value; //值

TreeNode<K,V> parent; //父节点的地址值

TreeNode<K,V> left;//左子节点的地址值

TreeNode<K,V> right;//右子节点的地址值

boolean red;//节点的颜色

2.添加元素

HashMap<String,Integer> hm = new HashMap<>();

hm.put("aaa" , 111);

hm.put("bbb" , 222);

hm.put("ccc" , 333);

hm.put("ddd" , 444);

hm.put("eee" , 555);

添加元素的时候至少考虑三种情况：

2.1数组位置为null

2.2数组位置不为null，键不重复，挂在下面形成链表或者红黑树

2.3数组位置不为null，键重复，元素覆盖

//参数一：键

//参数二：值

//返回值：被覆盖元素的值，如果没有覆盖，返回null

public V put(K key, V value) {

return putVal(hash(key), key, value, false, true);

}

//利用键计算出对应的哈希值，再把哈希值进行一些额外的处理

//简单理解：返回值就是返回键的哈希值

static final int hash(Object key) {

int h;

return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

}

//参数一：键的哈希值

//参数二：键

//参数三：值

//参数四：如果键重复了是否保留

// true，表示老元素的值保留，不会覆盖

// false，表示老元素的值不保留，会进行覆盖

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {

//定义一个局部变量，用来记录哈希表中数组的地址值。

Node<K,V>[] tab;

//临时的第三方变量，用来记录键值对对象的地址值

Node<K,V> p;

//表示当前数组的长度

int n;

//表示索引

int i;

//把哈希表中数组的地址值，赋值给局部变量tab

tab = table;

if (tab == null || (n = tab.length) == 0){

//1.如果当前是第一次添加数据，底层会创建一个默认长度为16，加载因子为0.75的数组

//2.如果不是第一次添加数据，会看数组中的元素是否达到了扩容的条件

//如果没有达到扩容条件，底层不会做任何操作

//如果达到了扩容条件，底层会把数组扩容为原先的两倍，并把数据全部转移到新的哈希表中

tab = resize();

//表示把当前数组的长度赋值给n

n = tab.length;

}

//拿着数组的长度跟键的哈希值进行计算，计算出当前键值对对象，在数组中应存入的位置

i = (n - 1) & hash;//index

//获取数组中对应元素的数据

p = tab[i];

if (p == null){

//底层会创建一个键值对对象，直接放到数组当中

tab[i] = newNode(hash, key, value, null);

}else {

Node<K,V> e;

K k;

//等号的左边：数组中键值对的哈希值

//等号的右边：当前要添加键值对的哈希值

//如果键不一样，此时返回false

//如果键一样，返回true

boolean b1 = p.hash == hash;

if (b1 && ((k = p.key) == key || (key != null && key.equals(k)))){

e = p;

} else if (p instanceof TreeNode){

//判断数组中获取出来的键值对是不是红黑树中的节点

//如果是，则调用方法putTreeVal，把当前的节点按照红黑树的规则添加到树当中。

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);

//判断当前链表长度是否超过8，如果超过8，就会调用方法treeifyBin

//treeifyBin方法的底层还会继续判断

//判断数组的长度是否大于等于64

//如果同时满足这两个条件，就会把这个链表转成红黑树

if (binCount >= TREEIFY_THRESHOLD - 1)

treeifyBin(tab, hash);

break;

}

//e： 0x0044 ddd 444

//要添加的元素： 0x0055 ddd 555

//如果哈希值一样，就会调用equals方法比较内部的属性值是否相同

if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))){

break;

}

p = e;

}

}

//如果e为null，表示当前不需要覆盖任何元素

//如果e不为null，表示当前的键是一样的，值会被覆盖

//e:0x0044 ddd 555

//要添加的元素： 0x0055 ddd 555

if (e != null) {

V oldValue = e.value;

if (!onlyIfAbsent || oldValue == null){

//等号的右边：当前要添加的值

//等号的左边：0x0044的值

e.value = value;

}

afterNodeAccess(e);

return oldValue;

}

}

//threshold：记录的就是数组的长度 * 0.75，哈希表的扩容时机 16 * 0.75 = 12

if (++size > threshold){

resize();

}

//表示当前没有覆盖任何元素，返回null

return null;

}