目录
一、HashMap简介
HashMap是Java中一个非常常用的数据结构，它实现了Map接口，是基于哈希表的数据结构，可以用来存储key-value键值对。
HashMap的特点是快速定位和查找，可以在O(1)的时间复杂度内进行查找、插入、删除操作，但是需要注意的是，由于哈希冲突的存在，HashMap在并发情况下可能会出现数据丢失或者死循环等问题。
HashMap的内部实现采用数组和链表（或红黑树）的结构，通过哈希函数将key映射到数组的某个位置，并将value存储在该位置上。为了处理哈希冲突，HashMap采用链表（或红黑树）来存储同一个位置上的多个key-value节点。当链表长度较长时，将自动转换为红黑树，以提高插入、查找、删除的效率。
在使用HashMap时，需要注意的是，HashMap不是线程安全的，如果在多线程环境下使用需要进行同步控制或使用线程安全的ConcurrentHashMap或Hashtable。
二、HashMap实现原理
HashMap简介中已经大致说明了HashMap内部实现的原理（可见下图），该小节将详细介绍。
图片来源：给面试官讲解hashmap底层原理后，他表示很看好我 | w3cschool笔记
2.1 根据key值计算其hash值
哈希值也称为散列值（Hash Value/Hash Code），是指通过哈希函数将任意长度的数据（明文）压缩成固定长度的数据串（密文）的过程。哈希值通常是用来验证文件的完整性、作为加密算法的基础、以及在大规模数据处理和搜索中加快数据的查找等用途。
HashMap中获取hash值的操作如下：
static final int hash(Object key) {
int h;
// 使用Object中的hashCode方法，同时令hashCode值和它的高位做^运算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}HashCode是Java中Object类的一个方法，用于返回对象的哈希码值，哈希码值是由对象的地址或者其它唯一标识符转换成的一个int类型的值（共32位），用于在散列表等数据结构中进行快速查找。在Java中，如果两个对象的equals方法返回值相同（即表示两个对象相等），则它们的哈希码值应该相同；反之，如果两个对象的哈希码值不同，则它们不一定不相等，需要通过equals方法进一步比较确定是否相等。
从源码中可以看出，HashMap在获取到key值的HashCode后，还会将hashCode的低16位与高16位做异或操作，令hashCode的高位同样参与后续的数组下标计算，使得hash散列更加随机，减少了hash碰撞的概率。
2.2 根据hash值获取在数组中的索引
前文说过，HashMap是通过数组和链表（或红黑树）来实现存储的，那么如何获得数据在数组中的索引呢？
HashMap并不是直接将hash值作为数据在数组中的索引（因为hash值一般大于HashMap的数组容量），而是将根据hash值计算数组索引，计算方式如下：
// 其中tab为HashMap中的数组，i是数组索引，n是数组长度
p = tab[i = (n - 1) & hash]上述代码的含义是将数组长度减1之后，与hash值做与运算得到索引。那么问题来了，为什么一定要(n - 1) & hash呢? 直接令i = n & hash不是更加直观吗？
要回答上述问题，可以看如下解析：
HashMap中为了获取索引做与运算的时候，运算结果和参与运算的值的特点有很大关联
以hash值251为例 二进制表达为 1111 1011
当n=16时 （事实上，HashMap初始的数组容量就是16）
n & hash 结果如下
hash 1111 1011
n 1 0000
————————————————
1 0000
n-1 & hash 结果如下
hash 1111 1011
n-1 1111
————————————————
1011
从以上的运算中不难发现，当n是2的整数次幂时，其二进制表达是由一个1和后面的多个0构成，
这会导致与不同的hash值做与运算时极易产生相同的结果，数据散列十分不均匀
而n-1的二进制表达则是由多个1构成，与hash做与运算时相当于直接舍弃了hash高位部分而保留低位部分，
数据散列效果更好
事实上，当n是2的整数次幂时，n-1 & hash就相当于对hash值求n的余数（即hash%n，这样说是否能够更好地理解这种散列方式的优越性呢）。而为了保持上述良好特性，HashMap在每次对数组扩容时，都是采取乘2的操作，保证了数组长度始终是2的整数次幂。
2.3 node对象解析
还是那句话，HashMap是通过数组和链表（或红黑树）来实现的，2.2中介绍了数组索引的获取，接下来简单看看HashMap中链表的实现吧。
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;
}其实没什么特别可分析的，就是比一般的链表多了个hash属性，当然node内部还实现了equals等方法，但都比较简单，这部分简单了解一下就好。
2.4 hash碰撞分析
前文讲过，HashMap存储数据时，会根据key值的hash计算出其数组索引并将数据插入在相应位置，那么当插入数据时，若发现当前key映射到数组的索引位上已经有了数据，就会引发hash碰撞。此时HashMap会根据不同状况进行不同处理：
1.二者key值相等，替换数据
2.二者key值不相等，在该位置上的链表末尾插入新数据
3.二者key值不相等，且该位置上链表长度大于8，链表结构转为红黑树以提高查询效率
三、HashMap源码解析
好吧，其实这篇文章里只简单分析了HashMap几个重要（且简单）的方法，像一些太复杂的方法（比如链表转为红黑树，红黑树的插入、删除和退化为链表，以及数组的初始化和扩容等）源码暂时先放放。
先介绍一下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;3.1 构造方法
构造方法比较简单，重点看看那些参数需要被初始化就好了：
// HashMap的构造方法
// 传入初始容量和负载因子
public HashMap(int initialCapacity, float loadFactor) {
// 初始容量不得小于0
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// 初始容量不得大于最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 负载因子不得小于等于0
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
// 传入初始容量
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
// 传入一个Map对象作为参数
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}HashMap的构造方法主要实现对数组初始容量和负载因子的初始化，同时HashMap也能够接受其它Map对象作为输入来进行初始化。
3.2 put方法
put方法非常重要，也是HashMap实现原理最直观的体现，源码和解析如下：
public V put(K key, V value) {
// 调用了putVal
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
// table不存在就用resize函数初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// tab[i]位置上没有数据就直接根据传入的key，value来new一个node放在该位置
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// tab[i]位置上有数据，也就是hash冲突
// 注意此时p已经指向了当前位置链表的第一个元素
else {
HashMap.Node<K,V> e; K k;
// 原数据和新数据hash相等且key相等，那么先令e=p记录下来，之后再替换数据
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果该位置上已经转化成了红黑树，那么向该树中添加新进入的node
else if (p instanceof HashMap.TreeNode)
e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 其它情况
else {
for (int binCount = 0; ; ++binCount) {
// e遍历到了当前链表的末尾，在最后添加新的node即可
// 注意判断node个数是否超过了树化阈值 8个
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 如果遍历到了和新数据key值相等的地方，说明在这里要替换数据了，停止遍历并记录下来
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// p后移一位以实现链表遍历
p = e;
}
}
// e不为null则说明之前e没有遍历到链表末尾，表示有地方需要替换
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
// 提前返回了，size数量不会自增，也就不会触发扩容
return oldValue;
}
}
// modCount自增，size也自增，size超过阈值则触发扩容
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}3.3 get方法
get方法就简单很多了，重点是注意判断当前索引位置上是否已经树化了
// get方法
public V get(Object key) {
HashMap.Node<K,V> e;
// 调用getNode方法
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final HashMap.Node<K,V> getNode(int hash, Object key) {
HashMap.Node<K,V>[] tab; HashMap.Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 检查链表中第一个元素key值是否是所需key
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 HashMap.TreeNode)
return ((HashMap.TreeNode<K,V>)first).getTreeNode(hash, key);
// 遍历链表
do {
// 根据key值判断，找到所需node
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}3.4 remove方法
remove方法其实和get方法很像，需要注意的地方是如何正确地删除链表或红黑树中的元素
final HashMap.Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, index;
// 惯例，先检查table是否为空，以及table对应索引位置下数据是否为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
// 设置一个空node
HashMap.Node<K,V> node = null, e; K k; V v;
// 若当前链表第一个元素就是要删除的元素，则node=p
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
// 判断是否为红黑树，若是则获得要删除元素目前的node对象
if (p instanceof HashMap.TreeNode)
node = ((HashMap.TreeNode<K,V>)p).getTreeNode(hash, key);
else {
// 遍历数组并获得待删除元素目前的node对象
// 注意此时node=p.next
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
// 若树化了，则在红黑树里删除元素
if (node instanceof HashMap.TreeNode)
((HashMap.TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
// 若要删除的元素是链表中的第一个元素
else if (node == p)
tab[index] = node.next;
// 其它情况
// 注意这里node=p.next哦，node就是之前获取到的待删除的元素的引用
// p.next = node.next相当于把node本身删除了，直接让p指向node后一个元素
else
p.next = node.next;
// 操作次数增加
++modCount;
// HashMap中元素个数减少
--size;
afterNodeRemoval(node);
return node;
}
}
return null;3.5 replace方法
replace方法就和get方法更像了（甚至都调用的是getNode方法），没啥可分析的，大家看看源码就好
// replace方法
// 没啥好讲的，就是通过get方法获取到对应的node对象后，修改他的val即可
@Override
public boolean replace(K key, V oldValue, V newValue) {
HashMap.Node<K,V> e; V v;
if ((e = getNode(hash(key), key)) != null &&
((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
e.value = newValue;
afterNodeAccess(e);
return true;
}
return false;
}
@Override
public V replace(K key, V value) {
HashMap.Node<K,V> e;
if ((e = getNode(hash(key), key)) != null) {
V oldValue = e.value;
e.value = value;
afterNodeAccess(e);
return oldValue;
}
return null;
}四、后记
本文对于HashMap的实现分析的还是比较简单，源码里面很多方法都没有详细介绍，例如resize(),treeify(),putTreeVal(),removeTreeNode()等方法都是比较重要的。本文仅抛砖引玉，感兴趣的读者可以自行查阅资料。
笔者萌新一位，如有错漏之处还望多多包涵。
本文参考了以下文章（很多文章内容有所重复，就不一一列举啦）：
1057
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
