- 存放键值对
- JDK1.8之前基于数组加链表，之后改为数组加链表加红黑树，并且增加了扩容的优化
- 允许一个key为null，允许多个value为null
- 线程不安全
基本操作
//创建一个 map
Map<String, String> map = new HashMap<>();
//如果 key 不存在则插入数据，如果 key 已存在则更新数据
map.put("test", "哈哈");
//根据 key 获取 value
map.get("test");
//上面已经插入了 key，这里相当更新 key 的 value
map.put("test", "呵呵");
//删除 key 及 value
map.remove("test");
//遍历
for (String key : map.keySet()) {
System.out.println(key);
}
构造方法
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
PUT操作流程
首次添加元素，table为空，putVal方法中可以先看resize()方法初始化table。旧的容量（oldCap）以及阈值（oldThr）均为0，阈值是啥暂时不知道。
public V put(K key, V value) {
//取key的hashCode值、高位运算、取模运算。
return putVal(hash(key), key, value, false, true);
}
putVal方法中首次调用put，跟踪至resize方法，可以直接看到给新的容量和新的阈值赋值。
newCap = DEFAULT_INITIAL_CAPACITY;//此处容量为1<<4，16
//阈值为0.75*16=12，意思为当容量到达12时，扩容一次，0.75是默认的负载因子，没太理解别人说的负载因子可以大于1，最后再深入理解下
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
.
.
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;//创建新的table
if (oldTab != null) {//oldTab为空，不用看了，直接拿到首次初始化的table添加元素
.
.
}
回到putVal方法
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)//n是当前最大容量（首次16），与hash值按位与操作得到准备放入的index，如果这个index上没有元素，直接放置，若有，else
tab[i] = newNode(hash, key, value, null);//插入数组指定位置，并且是当前链表的头结点以及尾结点
else {//哈希碰撞：当前准备放入的index已有数据，放入链表
Node<K,V> e; K k;
//key哈希值相同，并且key的值相同，替换元素，这个不算哈希碰撞
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 {//往链表中新增一条数据，头结点是p
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);//当链表长度等于TREEIFY_THRESHOLD（8）时，链表转化为红黑树
break;
}
//链表中key值相同，退出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;//相当于指针后移一位
}
}
//不管是未哈希碰撞的数组中还是，发生哈希碰撞的链表中，还是红黑树中，找到了一个key是完全一样的元素，需要替换value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//操作数加1
if (++size > threshold)//插入完成后，如果size超过阈值，扩容
resize();
afterNodeInsertion(evict);
再重新看下扩容方法，
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) {//非首次put，扩容操作
if (oldCap >= MAXIMUM_CAPACITY) {//存入数据过多，移动端开发很难遇到吧
threshold = Integer.MAX_VALUE;
return oldTab;
}//扩容为原来的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
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;//oldtable引用移除，交由jvm释放
if (oldTab != null) {//将旧table中数据复制到新的newTab中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;//free掉数组中引用
if (e.next == null)//当前index只有一条数据，直接赋给newTab，位置可能会变为原位置+原cap
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)//红黑树复制过去，可能过去就不是红黑树了？答案是不会，hash值依然一样的，只是位置可能会变
((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;
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;
}
负载因子 DEFAULT_LOAD_FACTOR
此处说法，默认值为0.75，Node[] table的初始化长度length(默认值是16)，Load factor为负载因子(默认值是0.75)，threshold是HashMap所能容纳的最大数据量的Node(键值对)个数。threshold = length * Load factor。也就是说，在数组定义好长度之后，负载因子越大，所能容纳的键值对个数越多。
结合负载因子的定义公式可知，threshold就是在此Load factor和length(数组长度)对应下允许的最大元素数目，超过这个数目就重新resize(扩容)，扩容后的HashMap容量是之前容量的两倍。默认的负载因子0.75是对空间和时间效率的一个平衡选择，建议大家不要修改，除非在时间和空间比较特殊的情况下，如果内存空间很多而又对时间效率要求很高，可以降低负载因子Load factor的值；相反，如果内存空间紧张而对时间效率要求不高，可以增加负载因子loadFactor的值，这个值可以大于1。
个人理解：在长度为length的数组上，由于哈希碰撞可以有超过length条数据元素，HashMap碰撞越小效率越高，所以负载因子不宜超过1，超过1后，在增加元素时校验if (++size > threshold)扩容时可能会出现扩容失效，导致增加哈希碰撞概率 负载因子越大，扩容次数越小，哈希碰撞越频繁，反之负载因子越小，扩容次数越多，哈希碰撞概率越小
为什么要hash
根据hash值可以直接取到数据在线性表中index，查询时间复杂度为O(1)
哈希碰撞会带来什么问题
查询时间复杂度增加，指针链表和红黑树额外增加空间复杂度
hash算法,为什么可以存1个null key
static final int hash(Object key) {
int h;//为空时，index为0的位置
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
public int hashCode() {
return identityHashCode(this);
}
static int identityHashCode(Object obj) {
int lockWord = obj.shadow$_monitor_;
final int lockWordStateMask = 0xC0000000; // Top 2 bits.
final int lockWordStateHash = 0x80000000; // Top 2 bits are value 2 (kStateHash).
final int lockWordHashMask = 0x0FFFFFFF; // Low 28 bits.
if ((lockWord & lockWordStateMask) == lockWordStateHash) {
return lockWord & lockWordHashMask;
}
return identityHashCodeNative(obj);
}
