HashMap解读
简介
HashMap，内部结构是 数组+链表/红黑树 构成，很多时候都是多种数据结构组合。
构造函数
构造方法，可选择带参数 initialCapacity 表示初始化容量大小（数组容量，只能是2的幂次方，如果不是就会改为大于输入值的最小的2的幂次方），loadFactor扩容加载因子 选填，其中 initialCapacity 默认为16，loadFactor 为0.75
默认初始容量 DEFAULT_INITIAL_CAPACITY = 1 << 4 （16）
最大容量 MAXIMUM_CAPACITY = 1 << 30
默认加载因子 DEFAULT_LOAD_FACTOR = 0.75f
阈值 threshold = 容量 * 加载因子
threshold 在初始化的时候保存的是数组的大小，初始化以后保存的是阈值
转化为红黑树的阈值 TREEIFY_THRESHOLD = 8
树转链表的阈值 UNTREEIFY_THRESHOLD = 6
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);
}
怎么把输入值改为2的幂次方倍呢？
*///如果输入进来的大小不是2的倍数，会转换为最近大的2的倍数，比如说15-> 16,26->32
static final int tableSizeFor(int cap) {
/**
* cap = 10
* n = 10 - 1 = 9
* n= 1001 , n >>> 1 = 0100 n |= n >>> 1 1101
* n= 1101 , n >>> 2 = 0011 n |= n >>> 1 1111
* ....
*最后 n = 1111 = 15, return 16;
*/
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;
}
算法就是让二进制不断右移，与自己异或
put 方法
int hash, 对应的下表索引
K key, key值
V value, value值
boolean onlyIfAbsent, 如果true,不会修改已经存在的值
boolean evict 如果是false,不处于创建模式。
static final int hash(Object key) {// 散列函数，用来减低碰撞几率，将前十六位二进制也计算到其中
/**
* hashCode 0110 1011 1101 0001 1001 0011 1011 0001
* h >>> 16 0000 0000 0000 0000 0110 1011 1101 0001
* h 0110 1011 1101 0001 1111 1000 0110 0000 后面16位是前面16位于后面十六位的^,减少碰撞
*/
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
public V put(K key, V value) {
/**
* int hash, 对应的下表索引
* K key, key值
* V value, value值
* boolean onlyIfAbsent, 如果true,不会修改已经存在的值
* boolean evict 如果是false,不处于创建模式。
*/
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,//是否改变已经存在的值
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;// tab 指向数组的索引 p 对应坐标的值 n 数组大小 i 下标
//如果map为空，进行初始扩容操作，相当于延迟加载
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//(n - 1) & hash 数组下标，后16位计算
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null); //如果是第一个为null,赋值
else {
Node<K,V> e; K k;//如果正好和第一个元素key相同，将第一个节点引用赋值给e
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;
}
//如果遇到key重复，和上面一样
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果e != null 说明重复了，根据onlyIfAbsent判断是替换还是不动
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;//说明修改value值不计入操作次数
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
/**
* Returns a power of two size for the given target capacity.
*///如果输入进来的大小不是2的倍数，会转换为最近大的2的倍数，比如说15-> 16,26->32
static final int tableSizeFor(int cap) {
/**
* cap = 10
* n = 10 - 1 = 9
* n= 1001 , n >>> 1 = 0100 n |= n >>> 1 1101
* n= 1101 , n >>> 2 = 0011 n |= n >>> 1 1111
* ....
*最后 n = 1111 = 15, return 16;
*/
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;
}
hash() 方法
接着是hash(）
static final int hash(Object key) {// 散列函数，用来减低碰撞几率，将前十六位二进制也计算到其中
/**
* hashCode 0110 1011 1101 0001 1001 0011 1011 0001
* h >>> 16 0000 0000 0000 0000 0110 1011 1101 0001
* h 0110 1011 1101 0001 1111 1000 0110 0000 后面16位是前面16位于后面十六位的^,减少碰撞
*/
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
思考： 为何这么设计？
这段代码有个名字，叫扰动函数，大家想一下，如果hash函数直接使用key.hashCode()作为hash 值怎么样？
key.hashCode()获得的是key的hashcode(), 如果HashMap数组长度为16，求对象在数组存储位置 (n - 1) & hash 就相当于 0000 1111 & hash ，让 hash 高位全部置为0，只用到了 hash 的低位，因为只用了低位，碰撞的几率就会比较大。
聪明的算法设计者兼顾性能和降低碰撞，就考虑用高16位和低16位结合起来异或形成hash 值。如下图所示，
nLmNzZG4ubmV0L2NhaWppYmFpbmRhc2hlbg==,size_16,color_FFFFFF,t_70)
其实用处就是将全部的位置全部使用到，如果直接使用了hashCode,会增大膨胀几率，因为那面16位全是0（hashcode只有16位）
key的hashCode 为 0110 1011 1101 0001 1001 0011 1011 0001
hashCode >>> 16 0000 0000 0000 0000 0110 1011 1101 0001(就是将hashCode,前面填16个0，后面删去16位)
此时就把hashcode的前16位于后16位放在一起，进行^ 操作得：
0110 1011 1101 0001 1111 1000 0110 0000
数组扩容 resize()方法
newCap = oldCap << 1 每次扩容2倍 ，16->32 ,
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;
}
//否则进行扩容，先设置新容量，存在newThr
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// this.threshold = tableSizeFor(initialCapacity);//转换为大于且最近的2的次幂,设置数组大小
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
//如果是长链表 分为 高组 和 低组
/**
* 比如说16扩容到32位,比如oldTab[14]，低组就是tab[14],g高组tab[30]
* oldCap -1 =15对应的是1111，在hash & (oldCap -1) 时只会 运算后面四位
* 如果扩容为32 32-1 = 31 = 11111，计算时就会计算四位，如果原来倒水第五位时0，会得到01111，
* 放在低组，如果是1，得到11111，放在高组
*/
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;
}
这个怎么理解呢？看下面这张图，结合代码当中内容就可以很好地理解
分二种情况：
比如现在 数组长度为16，元素的hash值为0101 ， 0000 0101 & 0000 1111 = 0000 0101,
扩容之后，因为高位为0，0000 0101 & 0001 1111 = 0000 0101，位置没变，可以直接放到扩容后的原始位置。
数组长度为16，原始的hash值为 0001 0101， 0001 0101 & 0000 1111 = 0101, 扩容到32之后， 0001 0101 & 0001 1111 = 0001 0101, 比原来的位置大16。就是一部分放在原位置，一部分放置于扩容的那部分
有意思吧！ 好好品，越品越有意思！
红黑树与链表转换 Node与TreeNode 暂时不会。。。。
红黑树转为链表的临界值是6不是8，原因是如果长度经常在8附近，转来转去，浪费资源。
为什么红黑树的阈值是8，因为合理的hash函数，发生碰撞链表长度为8的概率作者计算为千万分之后
存储过程总结
判断数组是否为空，为空进行初始化;
不为空，计算 k 的 hash 值，通过 (n - 1) & hash计算应当存放在数组中的下标 index ;
查看 table[index] 是否存在数据，没有数据就构造一个Node节点存放在 table[index] 中；
存在数据，说明发生了hash冲突, 继续判断key是否相等，相等，用新的value替换原数据(onlyIfAbsent为false)；
如果不相等，判断当前节点类型是不是树型节点，如果是树型节点，创建树型节点插入红黑树中；
如果不是树型节点，创建普通Node加入链表中；判断链表长度是否大于 8， 大于的话链表转换为红黑树；
插入完成之后判断当前节点数是否大于阈值，如果大于开始扩容为原数组的二倍
获取方法 get方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != 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);
}
}
//找不到，返回null
return null;
}
删除方法 remove() 方法
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**
* Implements Map.remove and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to match if matchValue, else ignored
* @param matchValue if true only remove if value is equal
* @param movable if false do not move other nodes while removing
* @return the node, or null if none
*/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {//判断链表存在
Node<K,V> node = null, e; K k; V v;
//如果第一个就是，赋值给node
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
//树
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
//不是链表头位置
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//此时如果存在就是node,否则不存在 matchValue 是否需要确定value也要相同
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
取代方法
@Override
public boolean replace(K key, V oldValue, V newValue) {
Node<K,V> e; V v;
if ((e = getNode(hash(key), key)) != null &&
((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
//当有值且value相同的时候进行修改 == 和 equals 满足一个就可以
e.value = newValue;
afterNodeAccess(e);
return true;
}
return false;
}
关于红黑树以及EntrySet后面进行补充 待续
43万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
