HashMap是Map基于哈希散列算法的实现，其在JDK1.7中采用了数组＋链表的数据结构。在JDK1.8中为了提高查询效率，采用了数组+链表+红黑树的数据结构。基于JDK1.8进行讲解。
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
从上面HashMap的定义可以看出，其继承了AbstractMap，实现了Map接口。
原理
从类成员变量，构造方法，核心方法，扩容机制几个方向介绍HashMap。
类成员变量
// 默认大小
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大大小
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认扩展因子
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;
// 桶数组
transient Node<K,V>[] table;
// 大小
transient int size;
// 调整阈值
int threshold;
// 扩展因子
final float loadFactor;
// 省略其他不重要的变量
在上面的类成员变量中，最重要的是 table 这个变量，其实是一个 Node 类型的数组。我们知道 HashMap 是一个数组 + 链表 + 红黑树的结构
这里的table数组就相当于bucket数组，而每个数组下标都对应着一个个的Node节点。这个Node节点可能是链表节点，也可能是红黑树节点。Node节点的类关系
HashMap.TreeNode ————> LinkedHashMap.Entry ————> HashMap.Node<K,V> ----> Map.Entry<K,V>
在这类关系中，最上层是Map.Entry接口，其是一条数据的抽象化，有key和value各种操作。接着，HashMap.Node实现了Map.Entry接口，并且增加了hash，key，value，next等属性，表示其是一个哈希节点。接着，LinkedHashMap.Entry继承了HashMap.Node节点，并且增加了before，after节点用来存储元素的插入顺序，其表示一个维护着插入顺序的链表哈希节点。最后，HashMap.TreeNode继承了LinkedHashMap.Entry,并且增加了parent，left，right，prev，red节点用来存储红黑树相关信息，表示其是一个红黑树节点。但因为其继承自LinkedHashMap.Entry，所以其也维护了插入元素的顺序。
看完Node节点的类关系，再来看HashMap中定义的Node类型table数组。这个Node的类型就是HashMap.Node。如果该桶是链表，那么插入的是HashMap.Node对象，如果是红黑树，那么插入的是HashMap.TreeNode对象。
构造方法
HashMap一共有4个构造方法
HashMap 一共有 4 个构造方法。
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);
}
上面这几个构造方法中，比较值得注意的是第 3 个构造方法。其中有这个一行代码：
this.threshold = tableSizeFor(initialCapacity);
从上面的代码我们可以看到：其调用了 tableSizeFor 方法，并将 initialCapacity 作为参数传入，最后将返回值设置给了 this.threshold。我们先看看 tableSizeFor 方法。
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;
}
简单说tableSizeFor的作用就是：找到大于或等于cap的最小2的幂。
最后我们回到刚刚的那个构造方法：
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);
}
我们仔细看就会发现，虽然传入了initialCapacity，但是这里貌似没有进行数据的初始化。没错，HashMap在创建的时候并不会进行数据的初始化，而是在真正插入的时候才进行初始化操作。
核心方法
对于HashMap来说，作为核心的几个方法：get，put，remove。
get
HashMap的查找操作比较简单，首先定位键值对所在桶的位置，之后再对链表或红黑树进行查找。
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;
//1. 桶不为空，那么进行查找，否则直接返回null
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//1.1 检查要查找的是否是第一个节点
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//1.2沿着第一个节点继续查找
if ((e = first.next) != null) {
//1.2.1如果是红黑树，那么调用红黑树的方法查找
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//1.2.2如果是链表，那么采用链表的方式查找
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
在上面计算key所在桶位置时，采用的是与运算，而不是取余操作。
first = tab[(n - 1) & hash]) != null
HashMap 中的桶数组大小总是为2的幂。在这种情况下，(n-1) & hash 等价与对length取余。但取余的计算效率没有位运算高，所以这里也算是一个小的优化。
另外，在计算哈希值的时候，我们会发现hsah方法并不是直接用key.hashCode方法产生的哈希值，而是做了一些位操作。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
看到这个方法的逻辑好像是通过位运算重新计算hash，那么这里为什么要这样做呢？为什么不直接用键的hashCode方法产生hash呢？
这里我们的n(桶大小)都比较小，也就是说n - 1 非常的小。这样就会导致做与操作时，无论hash值的高4位是什么值，n - 1 & hash 的值的高四位都为0。也就是说hash只有低4位参与了计算，高位的计算可以认为是无效的。这样会导致哈希值只受hash低4位的影响，大大增加哈希碰撞的概率。
而 hash 方法中的 (h = key.hashCode()) ^ (h >>> 16) 其实是将 hash 值的高 16 位于低 16 位进行一次异或运算，从而加大低位信息的随机性，变相的让高位数据参与到计算中
put
我们先看看 put 方法的实现。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
可以看到 HashMap 的 put 方法其实是调用了 putVal 方法。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 1. 如果未初始化，那么调用 resize() 进行初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 2. 如果桶为空，那么直接插入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 2.1 如果插入的元素与桶第一个元素相同，那么直接跳出
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 2.2 如果第一个元素是红黑树节点，那么调用红黑树的插入方法
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 2.3 如果是链表节点，那么遍历到链表尾部插入。但如果中间找到了相同的节点，那么直接退出
else {
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;
}
}
// 3. 如果插入的key已经存在，那么根据参数判断是否替代旧值
// 这里的 e 如果不为 null，那么就存储着旧值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;