首先,看HashMap的属性:
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 默认初始容量,是2的倍数,1左移四位,就是1 0000 结果就是16
static final int MAXIMUM_CAPACITY = 1 << 30;
//最大容量,2的30次幂,1 073 741 824 ,10亿多。
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;
内部类,Node对象,有hash值,kv,以及next指针(指向的是hash冲突的下一刻节点)
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的四种构造方法
分别是
1 HashMap(int initialCapacity, float loadFactor)
2 HashMap(int initialCapacity)
3 HashMap()
4 HashMap(Map<? extends K, ? extends V> m)
一般使用的第三种、第四种
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);
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
在第一种构造方法中,有一个阈值的计算
static final int tableSizeFor(int cap) {
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;
}
意思是n移位,然后与自己按位与操作。
如果n为6 ,5二进制是 101 执行后,向右位移1位 010 ,按位或后是111,结果是7。
这样计算 的结果就是2的power -1 ,后面+1,是2的power且,大于cap。
HashMap的put方法实现
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;//节点数组,节点
if ((tab = table) == null || (n = tab.length) == 0//如果put前map是空的,那么初始化数组
n = (tab = resize()).length;//n必为2的power
if ((p = tab[i = (n - 1) & hash]) == null)
//相当于hash取余,映射到数组中,如果不冲突,就直接创建出来。
tab[i] = newNode(hash, key, value, null);//新建一个node
else {
// 如果有hash冲突
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//p为冲突的node,如果hash与key都相同,则e=p;
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 如果hash冲突了,则遍历list,冲突的node相同,就p=e,否则就新建。
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;
}
}
if (e != null) { // existing mapping for key 在list中已存在了相同的key了。
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
- put方法的思路
- 第一步 如果原map为空,初始化
- 第二步 如果hash映射后不冲突,直接在该位置创建
- 如果冲突且是相同key,相同hash,那么就不插入
- 第三步 如果有冲突,就遍历节点的list,看下一个为空否。
- 为空插入,不为空看是否冲突,是否相同。
- 如果list长度>= TREEIFY_THRESHOLD ,就创建红黑树
- 第四步 看size的大小,如果大于threshold,就重新设置threshold大小。
有冲突要么放到list、tree上,要么重复不插入