HashMap
了解HashMap之前首先了解它的最上层接口Map
Map：是一个映射集合，由键值对（Key-Value）组成，可以根据Key来获取Value。Map中Key是唯一的不可重复，但是value可以重复，一个键对应着唯一一个值。
Map的常用实现类有HashMap，Hashtable，Properties，TreeMap，LinkedHashMap等
HashMap：1、基于哈希表实现的Map类
2、数据访问是无序的
3、Key和Value都支持null值
4、在多线程的环境下不安全
Hashtable：1、基于哈希表实现的Map类
2、数据访问是无序的
3、Key和Value都不支持null值
4、在多线程的环境下安全
Properties：1、Properties是唯一一个与IO流结合的集合，也表示了一个持久的属性集。ProPerties可保存在流中或从流中加载
2、Key和Value固定为String类型
3、使用load方法可以将硬盘中的文件（文件中必须为键值对形式）读取到集合中使用
4、使用store方法可以将集合中的数据写入到指定文件中（以键值对的形式写入）
TreeMap：1、基于红黑树的NavigableMap类实现
2、可以根据Key的自然排序或者compareTo方法进行排序输出
3、在多线程的环境下不安全
LinkedHashMap：1、基于哈希表和双向链表实现的Map类
2、有序的，根据插入的顺序输出
3、Key和Value都支持null值
4、在多线程的环境下不安全
HashMap解析
在对HashMap进行解析之前，首先对哈希表进行一个学习
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。---百度百科
说的通俗一点就是，通过哈希函数将要存储的键值对中的键映射到数组中的某个位置，将值放入到该位置进行存储
如下图所示
由上可以得知，哈希函数设计的好坏直接影响到哈希表的优劣，好的哈希函数能够会尽可能的保证计算简单和散列地址分布均匀，但是再好的哈希函数一定能保证键的地址独一无二嘛，答案是否定的，正是因为如此就会发生哈希冲突，也叫哈希冲撞。
解决哈希冲突的方法有以下几种方法：
1、开放地址法
2、再哈希法
3、链地址法
4、公共溢出区法
HashMap解决哈希冲突的方法就是使用链地址法。
链地址法：每个哈希表节点都有一个next指针，多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这个单向链表连接起来。
HashMap创建了一个Node类用于存储数据和指向相同哈希值的Node地址
由源码可知Node类实现了Map.Entry接口，并且内部由四个属性
1、hash：该属性用于存放键所对应的hash值
2、key：用于存放键
3、value：用于存放值
4、next：用于指向相同hash值的下一个Node地址
通过以上的可以得知HashMap的底层数据结构如图下所示
总的来说，HashMap是由数组+链表的构成的数据结构集合，数组是HashMap的最主要的组成部分，而链表的存在就是为了解决哈希冲突的问题。如果定位到数组某个位置上发现没有链表，则它的查询的时间复杂度就为O(1)。如果有链表，则它的查询的时间复杂度就会变成了O(n)。因为链表的存在是为了解决哈希冲突的问题，但如果链表过长那么它的效率是不是就变低了呢？答案是肯定的，由于链表在物理空间上是不连续的，它只在逻辑空间上连续，通过指针指向下一个元素，所以它的随机查询的效率就会低。那么该如何解决这种问题呢？在JDK8中，HashMap增加了红黑树这一数据结构，红黑树的增加就是为了解决链表过长导致查询的效率低下的问题。
红黑树
红黑树（Red Black Tree） 是一种自平衡二叉查找树。红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。
它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。---百度百科
从百度百科的定义中我们可以得治，红黑树就是一种特殊的平衡二叉树，它需要满足一些额外的要求
性质1. 结点是红色或黑色。
性质2. 根结点是黑色。
性质3. 所有叶子都是黑色。（叶子是NIL结点）
性质4. 每个红色结点的两个子结点都是黑色。（从每个叶子到根的所有路径上不能有两个连续的红色结点）
性质5. 从任一节结点其每个叶子的所有路径都包含相同数目的黑色结点。
HashMap的属性
/*
HashMap中的键值对个数
*/
transient int size;
/*
HashMap被修改结构的次数。结构修改为HashMap中键值对的数量更改或者以其它方式修改其内部结构（如重新散列）。由于HashMap是一个多线程环境下不安全的一个集合，所以当在多线程环境下对HashMap进行结构修改的时候，就会根据该属性抛出ConcurrentModificationException异常
*/
transient int modCount;
/*
阈值，threshold=capacity * load factor。当超过这个阈值的时候，HashMap就会进行自动的扩容
*/
int threshold;
/*
负载因子，默认为0.75.负载因子的存在就是为了减缓哈希冲突导致的效率低下。与threshold和capacity一起使用
*/
final float loadFactor;
/*
用于存储HashMap数据的Node数组
*/
transient Node<K,V>[] table;
HashMap构造器
/*
空参构造，对loadFactor进行赋初值，使得loadFactor=0.75
*/
public HashMap()
/*
该构造方法首先会对loadFactor进行赋初值，使得loadFactor，然后调用putMapEntries(Map<? extends K, ? extends V> m, boolean evict)方法。该方法是将传进来的map进行一个复制，使得使用了该构造方法创建的对象有了初始值
*/
public HashMap(Map<? extends K, ? extends V> m)
/*
initialCapacity：初始的桶大小
loadFactor：负载因子
该方法首先判断initialCapacity是否小于0，小于抛异常。如果大于MAXIMUM_CAPACITY那么就会令initialCapacity=MAXIMUM_CAPACITY。判断initialCapacity之后，再接着判断loadFactor是否小于等于0或者判断是否是NaN就会抛出异常。如果判断都没有成功就为loadFactor，threshold赋值
*/
public HashMap(int initialCapacity, float loadFactor)
/*
initialCapacity：初始的桶大小
该构造方法实现就是调用public HashMap(int initialCapacity, float loadFactor) 方法，initialCapacity=initialCapacity
loadFactor=DEFAULT_LOAD_FACTOR(DEFAULT_LOAD_FACTOR=0.75)
*/
public HashMap(int initialCapacity)
在构造方法之中，并没有对Node数组进行初始化操作，只是对例如loadFactor，threshold进行初始化。Node数组的赋值发生在put方法中。
put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}//在调用put方法的时候，实际就是在调用putval方法
/*
hash:该参数为Key值根据hash方法算出来的哈希值
key:put传进来的键值
value:put传进来的键对应的值
onlyIfAbsent:要不要改变现有值
evict:是否处于创建模式
*/
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)//判断HashMap对象是否有Node数组，即当前HashMap是否为第一次put值。如果是的话就会进行resize操作，即为初始化操作。
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)//如果当前的HashMap中Node数组不为null，那么就会计算put进来的key所对应的哈希值位于Node数组的那个索引处。使用(n-1)&hash计算出该Key在Node数组的索引位置。根据当前索引位置判断当前的Node是否null，如果为null，那么就在直接在当前的索引处创建一个新的Node，并给Node赋值
tab[i] = newNode(hash, key, value, null);
else {//如果上个判断不成立，那么就说明发生了哈希冲突，因为之前说过，HashMap解决哈希冲突的办法是链地址法，即使用链表的方式来存储哈希值相同的值。
Node<K,V> e; K k;
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
//首先判断当前插入进来的值与首节点值的是否相同，判断的依据有：
//1、首节点的哈希值与插入进来的哈希值是否相同
//2、首节点的key值与插入进来的key值是否相同（比较的是地址）或者首节点的key值与插入进来的key值是否相同（比较的是具体的值）
//当上述两个判断条件同时成立则代表着插入进来的值与首节点的值相同，那么就将首节点赋值给临时节点，后续将会将新插入进来的value值覆盖到首节点上
e = p;
else if (p instanceof TreeNode)//前面说过HashMap在JDK8的时候就变为了数组+链表+红黑树，当链表长度大于7并且数组长度大于等于64的时候就会转换为红黑树，但是如果链表的长度大于7但是数组的长度小于64的时候就只会进行扩容的操作，不会将链表转换成红黑树，这条判断就是查看当前的数据结构是为链表还是红黑树，如果是红黑树就进行红黑树的插入方式
//返回的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);
//判断插入之后的链表长度是否>=7，如果>=7，那么就进行链表到红黑树的转换
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;
}
}
//从这里就可以知道临时节点的作用了，如果临时节点不为空，那么就说明当前HashMap中存在与插入节点相同的key值的节点
if (e != null) { // existing mapping for key
//取出临时节点的value值
V oldValue = e.value;
//判断onlyIfAbsent是否为false，或者oldValue是否为null。
//onlyIfAbsent值在传入的时候就默认为false，所以该条件一定成立
if (!onlyIfAbsent || oldValue == null)
//将插入的value值覆盖到与插入值相同的节点
e.value = value;
//该方法在HashMap中没有作用
afterNodeAccess(e);
//返回节点覆盖之前的值
return oldValue;
}
}
//没有发现与插入值相同的节点发生的put操作就会使得modCount+1
++modCount;
//首先进行size+1，然后判断size的值是否大于阈值。threshold=capacity * loadfactor，在不修改capacity和loadfactor的情况下，threshold默认大小为12
if (++size > threshold)
//大于就进行扩容操作
resize();
//该方法在HashMap中没有任何的作用
afterNodeInsertion(evict);
return null;
}
通过对HashMap中put方法进行了一个大概的讲解，对put方法就会有一个大致的了解。接下来就对该方法中其他的方法进行一个梳理（涉及到红黑树的方法暂不将，因为还不会。。）
hash方法
//进行key的哈希值计算
static final int hash(Object key) {
int h;
//通过查看源码可以发现，因为HashMap可以插入null值，所以HashMap就将key为null的值放置到Node数组的0索引上
//(h = key.hashCode()) ^ (h >>> 16)就通过画图来进行理解
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
在JDK8中，通过hashCode()的高16位与低16位进行异或运算(h = key.hashCode()) ^ (h >>> 16)。这样运算是考虑到在Node数组的长度较小的时候，也能保证高位和低位都能够参与运算。
使用&来计算数组的索引的原因是因为Node数组的长度总为2的n次方，所以（n-1）&hash==hash%（n-1），但是&运算比%运算速度更加的快捷
resize方法
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) {
//如果当前的桶大小大于最大的桶大小，那么就让HashMap的阈值为最大。当下一次超过阈值时，直接报错不在进行扩容操作
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;
//当阈值和桶大小都为0那么代表没有指定值就会赋值桶大小为默认值为16，阈值被赋值为默认的负载因子*默认的初始化桶大小=12，该情况出现在使用无参构造创建对象时
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的阈值在经过上面的判断之后还为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数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;//将新的Node数组赋值给table
//该判断用于判断是为初始化操作还是扩容操作，初始化操作不进行if语句中的操作
if (oldTab != null) {
//扩容操作
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {//判断循环的Node是否为空
oldTab[j] = null;//将原哈希桶置空以便GC
if (e.next == null)//如果当前的Node节点没有与链表或者红黑树相连，重新计算扩容后该节点所处的索引位置
//索引位置用节点的哈希值与扩容后的新的Node数组长度进行与计算
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)//当前节点的为红黑树节点，则说明扩容前的当前Node为数组+红黑树
//进行红黑树的扩容赋值
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//进入该语句就说明扩容前的当前HashMap底层结构为数组+链表
//因为扩容是翻倍的，所以原链表上的节点有可能在原位置，也有可能在新的位置
//低位链表头节点和尾节点
Node<K,V> loHead = null, loTail = null;
//高位链表头节点和尾节点
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;//临时节点 存放e的下一个节点
do {
next = e.next;
//利用&运算高效的性质，算出hash值与oldCap去模运算之后的结果，等于0代表结果小于oldCap放在低 位，否则就放在高位
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;
}
//高位链表索引位置为原索引+oldCap
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
HashMap线程不安全的点也就在于扩容操作，所以在并发的环境下就需要使用线程安全的ConcurrentHashMap
get方法
public V get(Object key) {
Node<K,V> e;
//通过getNode方法来获取Node节点，如果没有就返回null
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
//tab：临时存放桶。
//first：临时存放hash值计算得到对应索引位置的第一个节点
//e：临时节点
//n：桶的大小
//k：存放first节点对应的val
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//进行桶大小判断，并且为tab、n、first进行赋值
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//通过进行对hash值是否相同并且key值是否相同判断frist是否为查找的节点
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//对临时节点e赋值为first的下一个节点
if ((e = first.next) != null) {
//判断当前是否为红黑树
if (first instanceof TreeNode)
//根据getTreeNode方法来对红黑树进行查找
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;
}
总结
1、尽量使用位运算符进行运算，效率更高
2、链表转为红黑树有两个条件，一个是链表的长度大于等于8，第二个条件为当前桶大小大于64。只有这两个条件同时成立了，才会进行链表转换红黑树
3、扩容每次都是容量翻倍，所以翻倍之后节点要么仍然在原位置，要么在原位置+原桶大小的位置。位置是否改变与节点hash值有关
4、在扩容的时候会将原桶置为null，方便GC
5、扩容操作在并发的环境下不安全，所以在并发的环境下使用ConcurrentHashMap
6、可以根据实际要求来指定loadFactor和initialCapacity，以便提高一定的效率
7、HashMap允许null值，null值存放的索引位置都存放在索引为0处
