简介
- HashMap存储无序
- 键和值都可以时null，但键位置只能又一个null
- 键位置是唯一的，底层的数据结构控制键
- jdk1.8以前数据结构是：数组+链表；jdk1.8之后是：数组+链表+红黑树。
- 链表节点数>8且数组长度大于64，才能将链表转换为红黑树，目的是为了提高查询效率。
- 树节点所占内存是链表节点的2倍
底层数据结构
数组在知道下标之后查询速度尤其快，O(1)的时间复杂度
链表在增删的时候速度非常快，找到位置后（前提），处理只需要O(1)的时间复杂度，因为不需要移动数据的位置，只需要更改指向的地址即可。但是链表在遍历对比的时候非常慢，时间复杂度为O(n)，所以用来做 哈希冲突时的解决方法
所以查询一个数据的时间复杂度为 O(1)+O(n)。不过因为哈希算法的非常巧妙，会让冲突尽可能地均匀分布，所以链一般极其短。所以后面遍历链表的时间可以忽略不计，而且在 JDK8 之后，如果冲突的链表长度大于 8，那么就会转化为 红黑树，他的遍历的时间复杂度为O(log n)
HashMap源码理解
成员变量
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
//序列号，序列化的时候使用。
private static final long serialVersionUID = 362498820763181265L;
/**默认容量，1向左移位4个，00000001变成00010000，也就是2的4次方为16，使用移位是因为移位是计算机基础运算，效率比加减乘除快。**/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量，2的30次方。
static final int MAXIMUM_CAPACITY = 1 << 30;
//加载因子，用于扩容使用。
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//当某个桶节点数量大于8时，会转换为红黑树。
static final int TREEIFY_THRESHOLD = 8;
//当某个桶节点数量小于6时，会转换为链表，前提是它当前是红黑树结构。
static final int UNTREEIFY_THRESHOLD = 6;
//当整个hashMap中元素数量大于64时，也会进行转为红黑树结构。
static final int MIN_TREEIFY_CAPACITY = 64;
//存储元素的数组，transient关键字表示该属性不能被序列化
transient Node<K,V>[] table;
//将数据转换成set的另一种存储形式，这个变量主要用于迭代功能。
transient Set<Map.Entry<K,V>> entrySet;
//元素数量
transient int size;
//统计该map修改的次数
transient int modCount;
//临界值，也就是元素数量达到临界值时，会进行扩容。
int threshold;
//也是加载因子，只不过这个是变量。
final float loadFactor;
常用内部类：
-
红黑树节点类
使用静态内部类，是为了方便调用，而不用每次调用里面的属性或者方法都需要new一个对象。
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent;
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev;
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
}
- 链表节点类：是一个单向链表。
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;
}
}
上面这两个内部类再加上之前的Node<K,V>[] table属性，组成了hashMap的结构，哈希桶。
构造方法
基本的构造方法：第一个，空参构造，使用默认的加载因子0.75；第二个，设置初始容量，并使用默认的加载因子；第三个，设置初始容量和加载因子，其实第二个构造方法也是调用了第三个。
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
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(Map<? extends K, ? extends V> m) {
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) {
//判断table是否初始化，如果没有初始化
if (table == null) { // pre-size
/**求出需要的容量，因为实际使用的长度=容量*0.75得来的，+1是因为小数相除，基本都不会是整数，
容量大小不能为小数的，后面转换为int，多余的小数就要被丢掉，所以+1。
例如，map实际长度22，22/0.75=29.3,所需要的容量肯定为30，有人会问如果刚刚好除得整数呢，除得整数的话，容量大小多1也没什么影响**/
float ft = ((float)s / loadFactor) + 1.0F;
//判断该容量大小是否超出上限。
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
/**对临界值进行初始化，tableSizeFor(t)这个方法会返回大于t值的，且离其最近的2次幂，例如t为29，则返回的值是32**/
if (t > threshold)
threshold = tableSizeFor(t);
}
//如果table已经初始化，则进行扩容操作，resize()就是扩容。
else if (s > threshold)
resize();
//遍历，把map中的数据转到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);
}
}
}
该构造函数，传入一个Map，然后把该Map转为hashMap，resize方法在下面添加元素的时候会详细讲解，在上面中entrySet方法会返回一个Set<Map.Entry<K, V>>，泛型为Map的内部类Entry，它是一个存放key-value的实例，也就是Map中的每一个key-value就是一个Entry实例，为什么使用这个方式进行遍历，因为效率高。
成员方法
1. put方法
获得下标过程(jdk8之前)：
首先看hash方法：
static final int hash(Object key) {
int h;
/**先获取到key的hashCode，然后进行移位再进行异或运算，为什么这么复杂，不用想肯定是为了减少hash冲突**/
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
capacity 的容量大小是 2 的 n 次幂，试想一下如果不做异或，而只是用原 hashcode ，那么在小 map 中，能起作用的就永远只是低位，虽然 hashCode 的生成已经分布的很平衡了，但相比较而言，同时考虑到高位与低位的影响，最后计算出的散列 index 发生碰撞的冲突肯定要小的多。
返回下标：
/**
* 返回数组下标
*/
static int indexFor(int h, int length) {
return h & (length-1);
}
HashMap 并没有采用 %(取余) 这种简单粗暴的实现，而是使用 &(按位与) 来分布散列 index 的生成，其主要目的当然是尽量减少碰撞冲突。相比较来说 % 的碰撞冲突应该是非常高的。
put方法：
public V put(K key, V value) {
/**五个参数，第一个hash值，
第四个参数表示如果该key存在值，如果为null的话，则插入新的value，
最后一个参数，在hashMap中没有用，可以不用管，使用默认的即可**/
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//tab 哈希桶数组，p 该哈希桶的首节点，n：hashMap的长度，i 计算出的数组下标
Node<K,V>[] tab; Node<K,V> p; int n, i;
//获取长度并进行扩容，使用的是懒加载，table一开始是没有加载的，等put后才开始加载
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/**如果计算出的该哈希桶的位置没有值，则把新插入的key-value放到此处，
此处就算没有插入成功，也就是发生哈希冲突时也会把哈希桶的首节点赋予p，在if括号内实现赋值**/
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//发生哈希冲突的几种情况
else {
// e 临时节点的作用， k 存放该当前节点的key
Node<K,V> e; K k;
//第一种，插入的key-value的hash值，key都与当前节点的相等，e = p，则表示为首节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//第二种，hash值不等于首节点，判断该p是否属于红黑树的节点
else if (p instanceof TreeNode)
/**为红黑树的节点，则在红黑树中进行添加，如果该节点已经存在，则返回该节点（不为null），
该值很重要，用来判断put操作是否成功，如果添加成功返回null**/
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//第三种，hash值不等于首节点，不为红黑树的节点，则为链表的节点
else {
//遍历该链表
for (int binCount = 0; ; ++binCount) {
//如果找到尾部，则表明添加的key-value没有重复，在尾部进行添加
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//判断是否要转换为红黑树结构
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
//如果链表中有重复的key，e则为当前重复的节点，结束循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//有重复的key，则用待插入值进行覆盖，返回旧值。
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//到了此步骤，则表明待插入的key-value是没有key的重复，因为插入成功e节点的值为null
//修改次数+1
++modCount;
//实际长度+1，判断是否大于临界值，大于则扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
//添加成功
return null;
}
代码示例：
HashMap<> hm = new HashMap<>();
hm.put("zhangsan", 1); //p1
hm.put("lisi", 2); //p2
hm.put("wangwu", 3); //p3
hm.put("zhangsan", 4); //p4
hm.put("wangwu", 5); //p5
假设"zhangsan"和"wangwu"的哈希值相同。则"lisi"和"wangwu"会放在数组同一个桶中。
执行p1，将table扩容，创建数组。将key进行hashcode()和hash，得到hash值，再通过i = (n - 1) & hash得到该Node在数组中的索引，判断该位置没有值，直接存入，返回null。。
执行p2，过程同p1插入值。
执行p3，将key进行hashcode()和hash，得到hash值，再通过i = (n - 1) & hash得到该Node在数组中的索引，判断该位置有值，即发生hash冲突，且不与头节点相同，也不为红黑树节点，进入第三种哈希冲突，遍历该位置的链表，若没有找到相同的key，则将此key-value添加到链表的末尾出，返回null。
执行p4，将key进行hashcode()和hash，得到hash值，再通过i = (n - 1) & hash得到该Node在数组中的索引，判断该位置有值，即发生hash冲突，且与头节点相同，执行第一种哈希冲突。通过用新值覆盖旧值，最后返回旧值。
执行p5，将key进行hashcode()和hash，得到hash值，再通过i = (n - 1) & hash得到该Node在数组中的索引，判断该位置有值，即发生hash冲突，且不与头节点相同，执行第三种哈希冲突，遍历该位置的链表，若找到相同的key则跳出for循环，然后通过用新值覆盖旧值，最后返回旧值。
2. resize方法
** 调用情景**
- 初始化数组table。在putVal函数中，(源码第628行)
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
- 进行扩容数组table的size达到阈值时，即++size > load factor * capacity 时，也是在putVal函数中
if (++size > threshold)
resize();
final Node<K,V>[] resize() {
//把扩容之前的哈希数组赋值给oldTab，用于后面将数据插入新数组。
Node<K,V>[] oldTab = table;
//old的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//old的临界值
int oldThr = threshold;
//初始化new的长度和临界值
int newCap, newThr = 0;
//oldCap > 0也就是说不是首次初始化，因为hashMap用的是懒加载
if (oldCap > 0) {
//大于最大值
if (oldCap >= MAXIMUM_CAPACITY) {
//临界值为整数的最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
//标记##，其它情况，扩容两倍，并且扩容后的长度要小于最大值，old长度也要大于16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//临界值也扩容为old的临界值2倍
newThr = oldThr << 1;
}
/**如果oldCap=0，但是已经初始化了，像把元素删除完之后的情况，那么它的临界值肯定还存在，
如果是首次初始化，它的临界值则为0
**/
else if (oldThr > 0)
newCap = oldThr;
//首次初始化，给与默认的值
else {
newCap = DEFAULT_INITIAL_CAPACITY;
//临界值等于容量*加载因子
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//此处的if为上面标记##的补充，也就是初始化时容量小于默认值16的，此时newThr没有赋值
if (newThr == 0) {
//new的临界值
float ft = (float)newCap * loadFactor;
//判断是否new容量是否大于最大值，临界值是否大于最大值
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
table = newTab;
//此处自然是把old中的元素，遍历到new中
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
//临时变量
Node<K,V> e;
//当前哈希桶的位置值不为null，也就是数组下标处有值，因为有值表示可能会发生冲突
if ((e = oldTab[j]) != null) {
//把已经赋值之后的变量置位null，当然是为了好回收，释放内存
oldTab[j] = null;
//如果下标处的节点没有下一个元素，即该节点为此位置的头节点
if (e.next == null)
//把该变量的值存入newCap中，e.hash & (newCap - 1)并不等于j
newTab[e.hash & (newCap - 1)] = e;
//该节点为红黑树结构，也就是存在哈希冲突，该哈希桶中有多个元素
else if (e instanceof TreeNode)
//把此树进行转移到newCap中
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
/**此处表示为链表结构，同样把链表转移到newCap中，
就是把链表遍历后，把值转过去，在置位null**/
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;
}
//原索引+oldCap
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 原索引放到bucket里
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 原索引+oldCap放到bucket里
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//返回扩容后的hashMap
return newTab;
}
将旧数组中的链表数据迁移至新数组的过程中，链表节点在新数组中下标的判断：
- resize方法源码融入了红黑树，本质和1.7区别不大,但是在插入元素的时候循环旧数组内的元素时会进行判断，如果是普通节点直接和1.7一样放置；如果是红黑树结构，就调用split（）方法进行拆分放置；如果是链表，则采用下面2中要分析的方式！！！！
- 在经过一次容量判断是否大于最大值之后在进行扩容，使用的扩容方法是2次幂的扩展，所以元素要么在原来的位置，要么在原位置在移动2次幂的位置，也即原index+oldCap，
如下图：图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。
因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：
上图a进行下表计算用到n-1的二进制位有4位，图b有5位，判断索引则根据新增加的这一位bit是0还是1。因此，其实我们在扩容的时候不需要像jdk1.7那样重新计算hash，只要看看原hash值新增的那个bit位是1还是0就好了，是0的话索引没有变，是1的话索引变成“原索引+oldCap（旧数组大小）”，下图位resize()方法示意图：
这个设计确实非常的巧妙，既省去了重新计算hash值的时间，也就是说1.8不用重新计算hash值而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。
3. remove方法
public V remove(Object key) {
//临时变量
Node<K,V> e;
/**调用removeNode(hash(key), key, null, false, true)进行删除，
第三个value为null，表示，把key的节点直接都删除了，
不需要用到值，如果设为值，则还需要去进行查找操作**/
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**第一参数为哈希值，第二个为key，第三个value，
第四个为是为true的话，则表示删除它key对应的value，不删除key,
第四个如果为false，则表示删除后，不移动节点**/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
//tab 哈希数组，p 数组下标的节点，n 长度，index 当前数组下标
Node<K,V>[] tab; Node<K,V> p; int n, index;
//哈希数组不为null，且长度大于0，然后数组在要删除key的节点算出来的index下有数据
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
//node 存储要删除的节点，e 临时变量，k 当前节点的key，v 当前节点的value
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不再是数组下标的节点，而是要删除结点的上一个结点**/
p = e;
} while ((e = e.next) != null);
}
}
//找到要删除的节点后，判断!matchValue，我们正常的remove删除，!matchValue都为true
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;
/**此方法在hashMap中是为了让子类去实现，主要是对删除结点后的链表关系进行处理**/
afterNodeRemoval(node);
//返回删除的节点
return node;
}
}
//返回null则表示没有该节点，删除失败
return null;
}
4. get方法
public V get(Object key) {
Node<K,V> e;
//也是调用getNode方法来完成的
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
//first 头结点，e 临时变量，n 长度,k 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 &&
((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);
}
}
//找不到，表示不存在该节点
return null;
}
5. 遍历
//方法一：通过 Map.keySet 遍历 key 和 value，多了个 getValue 的过程
for (String key : hashMap.keySet()) {
System.out.println("Key: " + key + " Value: " + hashMap.get(key));
}
//方法二：通过 Map.values() 遍历所有的 value，但不能遍历 key
for (String v : hashMap.values()) {
System.out.println("The value is " + v);
}
//方法三：通过 Map.entrySet 使用 iterator 遍历 key 和 value，而 iterator 又是要取出 entrySet的，相当于又多了一步。但其最大的特点是适用于一边遍历一边删除的场景。不需要用一个 set 先保存下来再删除了。
Iterator iterator = hashMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, String> entry = (Map.Entry<String, String>) iterator.next();
System.out.println("Key: " + entry.getKey() + " Value: " + entry.getValue());
// 遍历完成后马上进行删除
iterator.remove();
}
// 方法四：通过 entrySet 进行遍历，直接遍历出key和value。对于 size 比较大的情况下，又需要全部遍历的时候，效率是最高的。
for (Map.Entry<String, String> entry : entries) {
System.out.println("testHashMap: key = " + entry.getKey() + ";value = " + entry.getValue());
}
