HashMap的部分变量成员先列出来
//一个Node型的table数组指针
transient Node<K,V>[] table;
//Node结点类
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
HashMap的初始化
DEFAULT_INITIAL_CAPACITY
集合的初始化容量（必须是 2 的 n 次幂）默认16,也可以自己指定但提及一下,这里的16并不是是指数据量存到啦16才扩容,而是在数据达到16*0.75(负载因子)=12时就进行扩容
//自己指定容量大小,之后进入到一个参数的构造方法中
HashMap<String, String> stringStringHashMap = new HashMap<>(15);
源码部分
// 默认的初始容量是16 1 << 4 相当于 1*2的4次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//默认的负载因子（默认值 0.75）
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//哈希表的容量
int threshold;
//负载因子,非默认
final float loadFactor;
// 构造一个带指定初始容量和默认负载因子（0.75)的空 HashMap。
* public HashMap(int initialCapacity) {
//执行后进入到下方的构造方法去
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//两个参数的构造方法
* public HashMap(int initialCapacity, float loadFactor) {
//若指定的容量小于0,直接抛异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// 若指定的容量大于最大值,覆盖指定的容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//如果传入的loadfactor<0,报非法异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//之后进入到 下方tableSizeFor方法中,此函数能返回大于等于 initialCapacity 的最小的2的幂
this.threshold = tableSizeFor(initialCapacity);
}
* static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
//这里进行返回大于等于 initialCapacity 的最小的2的幂的运算,暂时还不清楚如何运算的
* public static int numberOfLeadingZeros(int i) {
// HD, Count leading 0's
if (i <= 0)
return i == 0 ? 32 : 0;
int n = 31;
if (i >= 1 << 16) { n -= 16; i >>>= 16; }
if (i >= 1 << 8) { n -= 8; i >>>= 8; }
if (i >= 1 << 4) { n -= 4; i >>>= 4; }
if (i >= 1 << 2) { n -= 2; i >>>= 2; }
return n - (i >>> 1);
}
为什么容量必须是 2 的 n 次幂？好处是什么?
HashMap 为了存取高效，减少碰撞，就是要尽量把数据分配均匀
这么做是如何减少碰撞的?
通过源码我们知道哈希表在计算索引时是通过hash & (length - 1)的方式计算的,这里我举个例子
- 假设有两个长度分别为8,9的哈希表
- 长度为 8 的时候，3 & (8 - 1) = 3，2 & (8 - 1) = 2，不同位置上，不碰撞
- 长度为 9 的时候，3 & (9 - 1) = 0，2 & (9 - 1) = 0，相同位置上，发生啦碰撞
- 通过上述例子可想而知,若容量不采用2 的 n 次幂的方式,会极大增加碰撞发生的几率(即哈希冲突)
总结
哈希表的put过程
在jdk8以后不是在HashMap的构造方法底层创建数组了，是在第一次调用put方法时创建的数组 Node[] table 用来存储键值对数据,来看jdk1.8后的源码
调用put方法
HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
objectObjectHashMap.put("1", "1");
首先进入HashMap的put方法
public V put(K key, V value) {
// hasn运算得出的hash值
||
\/
return putVal(hash(key), key, value, false, true);
}
之后再进入这个 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或者table指针是否为空,若条件为真,则将数组扩容为初始的16
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//这个地方进行table[通过上边得到的哈希值及table数组长度-1进行与运算得出的索引]是否为空的判断
if ((p = tab[i = (n - 1) & hash]) == null)
//若为空,说明此处没有值,将node结点加入此处
tab[i] = newNode(hash, key, value, null);
else {
//否则即产生哈希冲突,。若key值内容相同则替换旧的value，
//不然连接到链表后面，链表长度超过阈值8并且table长度大于64时就转换为红黑树存储。
Node<K,V> e; K k;
//这一步判断p(也就是确定)中的key是否与传入进来的key相同
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//若相同,将实例p结点的地址给e
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) {
//将新结点放入插入到最后一个结点的next处;
p.next = newNode(hash, key, value, null);
//放完后进行是否转为红黑树的判断;作用看下边的代码
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果key值相同,不做处理,直接break;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//若e不为null,则说明传入进来的key与节点中的key值相同
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//返回原来结点中旧的value;
return oldValue;
}
}
//能执行到这一步,说明上边的代码已完成存储值得操作
++modCount;
//判断size+1后是否需要进行扩容处理
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
static final int MIN_TREEIFY_CAPACITY = 64;
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//当tab数组的长度为0或者tab长度小于最小转换容量时,进行扩容处理
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
//否则进行转为红黑树的处理
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
总结
HashMap如何完成map之间的复制的?
包含另一个 “Map” 的构造函数
// 构造一个映射关系与指定 Map 相同的新 HashMap。
public HashMap(Map<? extends K, ? extends V> m) {
// 负载因子loadFactor变为默认的负载因子0.75
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
* final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//获取传入map的长度
int s = m.size();
if (s > 0) {
//判断参数集合的长度是否大于0，说明大于0
if (table == null) { // 判断table是否已经初始化
//假设此处传入map的size为6,则ft计算出来就为9
// float ft = ((float)s / loadFactor) + 1.0F; 这一行代码中为什么要加 1.0F ？
//s/loadFactor 的结果是小数，加 1.0F 与 (int)ft 相当于是对小数做一个向上取整以尽可能的保证更大容量，更大的容量能够减少 resize 的调用次数。所以 + 1.0F 是为了获取更大的容量。
//例如：原来集合的元素个数是 6 个，那么 6/0.75 是8，是 2 的n次幂，那么新的数组大小就是 8 了。然后原来数组的数据就会存储到长度是 8 的新的数组中了，这样会导致在存储元素的时候，容量不够，还得继续扩容，那么性能降低了，而如果 +1 呢，数组长度直接变为16了，这样可以减少数组的扩容。
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY);
// 此处因为是执行的是参数为map的有参构造,阈值threshold此时并不是无参构造中那样默认的16,值还是0,所以若计算得到的t若大于阈值，那挺好,直接初始化阈值为大于等于t的2的n次幂的值
//将t通过右移及或运算变为16,threshold赋值为16
if (t > threshold)
threshold = tableSizeFor(t);
}
// 若已初始化，threshold(阈值)已经有值啦,并且传入map的长度大于阈值，则只能进行扩容处理
else if (s > threshold)
resize();
// 将m中的所有元素添加至HashMap中
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
HashMap扩容resize()
jdk1.8后扩容计算索引的方式,是
比如当前存要put(“key”，“value”);
假设"key"的hashcode值为h,当前哈希表长度oldCapacity=4 ，现在要扩容，扩容后newCapacity=8(哈希表扩容后长度都是原来的一倍 )
/**源码部分*/
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;
}//正常扩容,原数组长度变为原来的一倍,左移一位,变大一倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//原阈值也变大为原来1倍
newThr = oldThr << 1; // double threshold
}//数组为空,第一次扩容
//oldThr在第一次创建map时,如果构造参数形参有值的话,oldThr是有值的,否则还是0
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);
}
//这步说明map在初始化时人为的将容量设为啦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"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//遍历这个node数组
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//将e指向此节点
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//若此节点的next为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
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//遍历这个链表
//注意 因为扩容的原因,部分链表元素计算hash后的索引会在原位置+数组长度处
//影响索引的位置因素是hash(key)的高位
//举例 某hash(key)的索引是11111,高位是1,与16位的map与运算后是在15索引处,
//但与32位map作运算后确是在31索引处
//若高位是0,hash(key)的索引是01111与16位的map与运算后是在15索引处,与32位map作运算后仍是在15索引处
//jdk做的处理是只判断高位因素,不再做rehash运算,将桶结点的链表分为高链,低链,之后再放入新数组中,高链低链均采用的是尾插法
do {
next = e.next;
//判断hash最高位是否是1或0
//此节点是低结点,以下都是尾插法的处理
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else { //判断hash最高位是否是1或0
//此节点是高结点,以下都是尾插法的处理
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;
}
1.8中对rehash做的优化,看这篇 1.8中resize的优化
总结
HashMap的get方法
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//tab若为null,返回null
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//判断桶结点key与传入的key相同?
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 {
//否则就是链表,按链表处理,遍历equals(key),符合就返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
总结
HashMap的Remove()方法
remove有两种形式,一种精确到key及value,一种有key就删除,matchValue默认传入false
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;
//长度为0或null就返回null
//p是经过key索引找到的结点,桶结点
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;
//若找到key的索引结点,赋值,表示在桶结点就找到啦要移除的结点
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 {
//链表处理,找到结点,赋值,此时p和node相同
do {
//这一步p一定是在node的前一个位置
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//找到结点,若!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
//f否则是在链表中找到啦,p在node的前边,删除结点的操作
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
总结
remove() 先判断tab是否为空,不为空就判断桶结点是否就是要移除的,若不是,再判断结点是不是红黑树,否则就是链表,遍历,找到要移除的结点,进行删除此节点的操作
1035
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
