作者：孤影
JDK 1.7 HashMap
1.0概述
元素以键值对的方式存储，无序不可重复，键值允许使用null，线程非安全的。
数据结构：数组+链表
如下方式
2.0 基本属性
//默认数组容量大小16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//数组最大容量2的30次幂
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认负载因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//初始化默认的数组
static final Entry<?,?>[] EMPTY_TABLE = {};
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
//键值对的数量
transient int size;
//扩容阈值
int threshold;
//负载因子
final float loadFactor;
//记录这个HashMap被修改的次数
transient int modCount;
......等
3.0构造方法
//当我们什么参数不传的时候
public HashMap() {
//使用默认的初始容量16，和负载因子0.75
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
}
//当我们只传初始容量参数的时候，负载因子使用默认0.75
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//无论我们传几个参数或者不传参都会调用到这个构造方法
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
//如果初始容量小于0抛出异常
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
//如果初始容量大于最大容量，那么容量就使用我们设定的最大容量
initialCapacity = MAXIMUM_CAPACITY;
//如果负载因子小于等于0或者不是一个合法的Float值，抛出异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//将初始容量和负载因子复制给threshold和loadFactor
this.loadFactor = loadFactor;
threshold = initialCapacity;
//初始化钩子，这里的初始化钩子里面没执行任何操作
init();
}
4.0内部类 Entry<K,V> 用来实际存储用户存进来键值信息等
static class Entry<K,V> implements Map.Entry<K,V> {
//键
final K key;
//值
V value;
//链表中下一个Entry对象
Entry<K,V> next;
//键的hash值
int hash;
}
5.0 方法
1.0 put方法和数组初始化方法
//这就是我们主要的put方法逻辑
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
//初始化table数组
inflateTable(threshold);
}
if (key == null){
//HashMap允许key是null，这里调用其他方法进行存值
return putForNullKey(value);
}
//将key进行hash
int hash = hash(key);
//根据hash值和数组容量大小-1，进行与运算得到我们put进来的值需要存放的数组位置的下标
int i = indexFor(hash, table.length);
//通过循环遍历判断这个链表里是否存在相同的key
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
//这个逻辑是判断如果插入这个键值对，key已经存在，就将新的值替换旧的值，并将旧的值返回
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
//修改的次数加一
modCount++;
//调用addEntry方法
addEntry(hash, key, value, i);
//如果不是已经存在的key ，返回null
return null;
}
/******************************************************/
//初始化数组
private void inflateTable(int toSize) {
//保证初始容量是2的指数次幂数，且大于我们传进来的初始容量的值
int capacity = roundUpToPowerOf2(toSize);//16
//计算出扩容阈值--->16*0.75=12
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
//创建一个Entry[]数组
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
1.1 indexFor 定位我们的值存在数组的索引位置
//根据hash值和数组容量大小-1，进行与运算得到我们put进来的值需要存放的数组位置的下标
static int indexFor(int h, int length) {
return h & (length-1);
}
/*****************************************************/
0001 1111
& 1010 1101
-----------------
0000 1101
其实我们这里可以很清楚看出无论任何值跟15进行与运算得出的值都是0-15之间，
这也是初始容量为什么必须是2的幂次方的原因之一
1.2 addEntry和createEntry
// 将我们存的值 添加到链表头部**
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
//键值对的数量大于或者等于阈值，并且我们数组的这个位置不是null的时候，
//我们将对数组进行2倍扩容
resize(2 * table.length);
//对这个key重新进行hash运算
hash = (null != key) ? hash(key) : 0;
//从新算出这个键值对应该存放在新的数组的索引位置
bucketIndex = indexFor(hash, table.length);
}
//无论我们有没有对数组进行扩容，都会执行这步，
createEntry(hash, key, value, bucketIndex);
}
/***********************************************/
//createEntry** 将新的Entry 添加到链表头部
void createEntry(int hash, K key, V value, int bucketIndex) {
//e就是当前链表的头节点
Entry<K,V> e = table[bucketIndex];
//创建一个新的Entry对象，并将这个Entry对象的next指向之前链表的头节点，实现头插
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
1.3 resize 和transfer
// 对数组进行扩容
void resize(int newCapacity) {
//将旧数组赋值给变量oldTable
Entry[] oldTable = table;
//就的数组长度 赋值给oldCapacity
int oldCapacity = oldTable.length;
//荣光旧数组的长度已经到达最大容量就不进行扩容了
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//创建一个新的 Entry[]数组，容量为传进来的newCapacity，也就是两倍扩容
Entry[] newTable = new Entry[newCapacity];
//执行
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
//transfer将旧数组的数据转移到新数组
void transfer(Entry[] newTable, boolean rehash) {
//新数组的容量
int newCapacity = newTable.length;
//遍历数组，获取所有的链表的头节点，Entry对象
for (Entry<K,V> e : table) {
//遍历这个链表
while(null != e) {
//next 指向这个节点的下一个节点对象
Entry<K,V> next = e.next;
if (rehash) {
//将key重新进行hash运算，但是
e.hash = null == e.key ? 0 : hash(e.key);
}
//通过新的hash值和新的数组大小，从新分配每个键值对存在数组的位置
int i = indexFor(e.hash, newCapacity);
//将这个节点的下一个指向新的数组下标为i的位置
e.next = newTable[i];
//将这个节点的Entry对象放入新的数组i下标的位置
newTable[i] = e;
//这个节点的下一个节点的对象的索引赋值给这个节点
e = next;
}
}
}
我们下面模拟数据迁移时链表的迁移的过程
未迁移前的图
whlie循环第一次
到e.next = newTable[i];时如下
第一次执行完毕; 如下
whlie第二次执行到e.next = newTable[i]
第二次执行完毕
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6QWDfXgY-1590908936855)(http://47.115.56.58:8088/hashMap6.png)]
弄明白正常情况下迁移的过程，下面我们来看看并发情况下如何产生死环的
假设线程1运行到 Entry<K,V> next = e.next;发生阻塞，这时候线程2也进入到了这个while循环，此时如下
while第一次
到e.next = newTable[i];时如下
这时候当线程2结束完while循环的样子，其实跟单线程执行完的样子差不多只是，线程1的
e和e.next仍然保留两个指针
如下
这时候我们看下线程1继续执行
线程1while循环第一次结束的样子
第二次结束
第三次结束e1=null循环完毕，到此new.next=new2，new2.next=new1形式死环
1.4 get 方法和get方法调用的方法
//这就是我们常用的get方法
public V get(Object key) {
if (key == null)
return getForNullKey();
//我们先通过key获取这个Entry对象
Entry<K,V> entry = getEntry(key);
//通过这个Entry对象获取值
return null == entry ? null : entry.getValue();
}
//个体Entry方法
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
//将key进行hash运算，通过这个hash值定位存在数组下标的位置
int hash = (key == null) ? 0 : hash(key);
//indexFor方法很熟悉了，就是通过hash值和数组的大小定位下标位置
for (Entry<K,V> e = table[indexFor(hash, table.length)];
//下面的流程就很简单了，就是遍历这个链表对比找出我们需要的值
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
//这个是内部内Entry的方法，所以这里就很好理解了
public final V getValue() {
return value;
}
JDK 1.8 HashMap
1.0 概述
元素以键值对的方式存储，无序不可重复，键值允许使用null，线程非安全的。
数据结构：数组+链表+红黑树
2.0 基本属性
//默认数组容量大小16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//数组最大容量2的30次幂
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认负载因子0.75
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;
//还是我们熟悉的数组table
transient Node<K,V>[] table;
transient Set<Map.Entry<K,V>> entrySet;
//键值对的数量
transient int size;
//记录这个HashMap被修改的次数
transient int modCount;
//扩容阈值
int threshold;
//负载因子
final float loadFactor;
......等
3.0 构造方法
//跟1.7基本一致
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;
//对我们传进来的初始化大小进行计算，保证是2的幂次方且小于等于最大容量
this.threshold = tableSizeFor(initialCapacity);
}
4.0 内部类 Node，替换了1.7的Entry，内部基本一致
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
5.0 方法
1.0 put方法及其依赖的方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* 我们存值的核心方法
*
* @param hash key的hash值
* @param key 键
* @param value 值
* @param onlyIfAbsent 这里是限制如果存在相同key是否可以修改值
* @param evict table是否初始化了
* @return 如果存在相同的key且，允许修改值那返回旧值，否则返回我们存的值
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//Node数组
HashMap.Node<K,V>[] tab;
//单个Node对象或者红黑树或者是链表
HashMap.Node<K,V> p;
//数组的大小
int n;
//就是定位我们存的值该放在数组下标的位置
int i;
//如果这个数组为空或数组的大小为0,我们直接进行扩容
if ((tab = table) == null || (n = tab.length) == 0){
//将数组扩容并赋值给tab，并将这个新的数组的大小赋值给n
n = (tab = resize()).length;
}
//如果这个数组下标为i的位置为空
if ((p = tab[i = (n - 1) & hash]) == null){
//调用Node的构造方法创建一个Node对象，放入tab[i]的位置
tab[i] = newNode(hash, key, value, null);
}else {
//进入这个else，证明下标为i的位置肯定有值了，
//Node对象e，主要作用如果键已经在时候用来返回旧值的
HashMap.Node<K,V> e;
//键
K k;
//这时候的p就是tab[i]位置的对象了
//所以可以很清楚看到这里是判断这个key跟跟tab[i]位置的key一直
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))){
//赋值给变量e
e = p;
}
//如果p是一个红黑树
else if (p instanceof TreeNode)
e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//进入这个else就确定是链表了
for (int binCount = 0; ; ++binCount) {
//将p的下一个节点对象赋值给e，并判断是不是null，
// 如果是null就存在这个位置，实现链表尾插操作，并终止循环
if ((e = p.next) == null) {
//创建一个Node对象进行尾插操作
p.next = newNode(hash, key, value, null);
//判断循环的此时是否大于或等于链表阈值8-1（因为我们循环是从0开始的，所以需要-1）
//也就是当链表大于8的时候需要转红黑树了
if (binCount >= TREEIFY_THRESHOLD - 1){
//转成红黑树，并将这个值也存到红黑树里
treeifyBin(tab, hash);
}
//终止循环
break;
}
//如果这个链表中存在相同的key，终止循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))){
break;
}
//将e赋值给p实现链表的继续遍历
p = e;
}
}
//这个e，如果我们存在相同键的时候就是旧的对象，否则就是null
if (e != null) {
//将这个对象的值作为返回值
V oldValue = e.value;
//如果这个值不允许修改或者这个值是null
if (!onlyIfAbsent || oldValue == null){
e.value = value;
}
afterNodeAccess(e);
//将这个值返回
return oldValue;
}
}
++modCount;
//size++，如果到达数组扩容阈值进行扩容
if (++size > threshold){
resize();
}
afterNodeInsertion(evict);
return null;
}
1.1 resize方法
final HashMap.Node<K,V>[] resize() {
//将旧的table赋值给临时变量oldTab
HashMap.Node<K,V>[] oldTab = table;
//旧的数组大小
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//就的数组扩容阈值
int oldThr = threshold;
//新的数组容量
int newCap;
//新的数组阈值
int newThr = 0;
//如果旧数组不是空数组
if (oldCap > 0) {
//如果就数组大于等于数组最大容量，我们就不扩容了
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//newCap = oldCap << 1 将就数组容量扩大两倍
//如果扩大两倍的值小于最大数组容量（2的30次方），
// 并且旧的数组容量大于等于初始容量16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//将旧的阈值乘以2赋值给新的阈值
newThr = oldThr << 1;
}
//如果就得数组是空的，并且旧的阈值大于0，就将旧的阈值作为新数组的容量
else if (oldThr > 0)
newCap = oldThr;
else { // 进入这个else就是数组是空数组，阈值为0，那么新数组就使用默认的初始值
//16
newCap = DEFAULT_INITIAL_CAPACITY;
//12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的阈值等于0
if (newThr == 0) {
//新的数组容量乘以负载因子（0.75）
float ft = (float)newCap * loadFactor;
//对最大值限制处理，最终大致就是将上面的ft设置新的数组阈值
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//将局部变量newThr赋值给我们的属性变量（数组阈值）
threshold = newThr;
//这个注解就是屏蔽掉一些警告
@SuppressWarnings({"rawtypes","unchecked"})
//创建一个新的数组容量为newCap， 一般正常就是两倍扩容
HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap];
table = newTab;
//如果就数组不为空，我们还是进行数据迁移
if (oldTab != null) {
//遍历旧的数组
for (int j = 0; j < oldCap; ++j) {
HashMap.Node<K,V> e;
//如果数组下标为j的位置不为空就赋值给变量e
if ((e = oldTab[j]) != null) {
//将就数组下标为j的位置置为空
oldTab[j] = null;
//如果就是一个单纯的单节点Node对象，
// 就从新计算这个Node对象应该存到新数组哪个位置，并将其存入
if (e.next == null)
//e.hash & (newCap - 1) 假设newCap==32，这个救过就是0-31之间的数了
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof HashMap.TreeNode)
//如果这个位置是个红黑树，我们就将红黑树进行拆分
((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // 我们来关注这里是链表的迁移，解决了1.7版本的死环问题
//低位头
HashMap.Node<K,V> loHead = null;
//低位尾
HashMap.Node<K,V> loTail = null;
//高位头
HashMap.Node<K,V> hiHead = null;
//高位尾
HashMap.Node<K,V> hiTail = null;
//next指针控制遍历链表的
HashMap.Node<K,V> next;
do {
next = e.next;
/**
* oldCap 16
* e.hash 随机数
* 0010 0000
* & 1010 1010
* -----------------
* 我们可以看得出 这样的结果只有两种
* 一种就是0，一种就是16，
* 这里又体现了为什么容量一定要是2的指数次幂
*
* 如果是0，我们就将其归位低位链表中，
* 如果是16，我们就将其归位高位链表中
*/
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;
}
//do里面的代码执行完毕就基本将一个链表均匀拆分成两个链表
//一个是高位链表，一个是低位链表
} while ((e = next) != null);
//如果低位链表的尾节点不为null，也就代表这个链表不为空
if (loTail != null) {
//这时我们这个尾节点的下一个指向null，不然会产生死环
loTail.next = null;
//将头结点存入数组[j]的位置，这个j就是0-15
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
//将这个头节点存入数组 ，刚好这里使用j+16，也就是存到16-31这些位置
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//将新的数组返回
return newTab;
}
扫一扫
8279
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
