一、HashMap简介
HashMap是一种基于数组+链表+红黑树的数据结构，其中红黑树部分在JDK1.8后引入，当链表长度大于8的时候转换为红黑树。
HashMap继承于AbstractMap（Map的骨架实现类），实现Map接口。
HashMap因为采用hashCode的值存储，所以性能一般情况下为O（1）。
HashMap最多只允许一条记录的键为null，允许多条记录的值为null。
HashMap线程不安全，如在多线程环境下可以使用Collections工具类将其转换为线程安全，也可使用JDK提供的CocurrentHashMap，不建议使用HashTable，理由是并发性能一般。
二、HashMap存储结构分析
HashMap用哈希表存储元素，其中采用链地址法解决冲突。
Node<K,V>是HashMap的内部实现类，实现Map.Entry<K,V>。
源码为：
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其他的几个属性：
transient Node<K,V>[] table; //数组 transient int size; //实际存在键值对数 transient int modCount; //修改次数 int threshold; //所能容纳的key-value对极限 final float loadFactor; //负载因子 默认为0.75不建议修改
其中table默认的构造长度是16，并且要求length是2的n次方，这是一种非常规的设计，主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap定位哈希桶索引位置时，也加入了高位参与运算的过程。
当数据量增大后，即便负载因子和Hash算法设计的再合理，也避免不了链表长度增加，如此一来就会影响HashMap的性能，所以JDK1.8开始引入了红黑树，利用红黑树高性能的增删查改解决这一问题，这里不讨论红黑树。
三、HashMap的功能实现
1）构造HashMap
HashMap有四个构造函数：
以下就源码逐个分析构造函数
public HashMap(int initialCapacity, float loadFactor) { //构造时传入指定大小以及负载因子
if (initialCapacity < 0) //容量大小合法性判断
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity); //最大容量只能为MAXIMUM_CAPACTITY，2的30次方
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); //设置阈值，当存储数据量达到阈值，将进行扩容，扩大为原来的2倍
}
public HashMap(int initialCapacity) { //指定容量大小，负载因子使用默认值0.75，调用上面的构造器
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() { //无参构造器，设置负载因子为默认值
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(Map<? extends K, ? extends V> m) { //包含子map的构造函数
this.loadFactor = DEFAULT_LOAD_FACTOR; //设置默认负载因子
putMapEntries(m, false); // 将传入的map元素逐个加入到HashMap中
}
2）确定数组索引位置
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这是JDK1.8中确定数组索引的方法，h = key.hashCode() 为第一步 取hashCode值，h ^ (h >>> 16) 为第二步 高位参与运算，这里的Hash算法本质上就是三步：取key的hashCode值、高位运算、取模运算。
3）HashMap的put方法
首先是逻辑分析，put方法的处理逻辑：
①.判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容；
②.根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③；
③.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals；
④.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤；
⑤.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；
⑥.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。
看源代码实现：
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; //tab为空则新建
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; //计算index，并处理null
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k; //通过hashcode值以及equals方法判断key是否存在，是的话直接覆盖value
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 { //不是红黑树 是链表
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null); //如果链表长度大于8转换为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
} //key已经存在直接覆盖value
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for 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;
}
4）扩容机制
Java中数组扩容是无法自动扩容的，方法是用新数组代替旧数组。融入了红黑树后，resize方法复杂度大大增加，这里简单说下1.7的处理的过程：
传入新的容量--引用扩容前的数组--判断是否达到最大容量--初始化新数组--复制数据--设置table属性引用新的数组--修改阈值
5）HashMap的get方法
HashMap存储元素是通过计算HashCode值确定精确索引存放的，但是不同的key是有可能出现有相同的HashCode值的，这时候他们会被存放在同一个桶中（bucket），
然后通过equals方法来确保key的唯一性。
因此当取出数据时，就要根据hash算法找到在数组的存储位置，再根据equals方法从该桶中找出对应的数据。
明白了逻辑以后看源代码实现：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object 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 && // 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 { //在链表中获取
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
针对HashMap的学习主要理解它的存储结构，工作原理，工作原理可以通过put与get方法去理解，期间可能产生扩容；另外要明白hashcode和equals两个方法在HashMap中
的作用。此外还有一些常用的方法containsKey，clear，remove，可以查看源码学习。