前言
HashMap：Java集合框架中相当具有代表意义并且日常开发中使用率相当高的一个工具类，其实现的基本数据结构是数组+链表+红黑树（JDK1.8）；
本文主要基于JDK1.8，同时也穿插提到一些JDK1.7的特性，用来对比两个版本之间的差异；从源码出发，学习HashMap的底层设计，其基本用法不再赘述。
重要属性
-
threshold：当存储元素size达到该值，并且再次插入时，会进行扩容操作（
resize()），并且每次HashMap容量发生变化时，值会重新计算；
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
-
loadFactor：负载因子，当HashMap中已经存储的元素数量size达到负载临界值就会进行扩容；默认值为
0.75f，可在HashMap构造方法中自定义指定值； - size：当前HashMap已经存储的元素数量；
-
modCount：记录HashMap被修改的次数，会在
put()操作和remove()操作时自增1，用于HashMa的快速失败（fast-fail）机制，即迭代时进行写操作（put，remove等），抛出java.util.ConcurrentModificationException异常； - table：Node数组，存放键值对，key和value真正存放的地方，JDK1.7中为Entry数组，Node是JDK1.8中新定义的数据结构；
transient Node<K,V>[] table;
- 相比较JDK1.7，JDK1.8的HashMap引入了红黑树的概念，使得HashMap的索引性能再次提升。
在JDK1.7中，当发哈希碰撞时，所有value节点都会存在那个index位置开始的一个链表上，在1.8中，当链表达到一定长度时就会转化成红黑树以提升索引效率。
（1）TREEIFY_THRESHOLD：树形化阈值，链表转化为红黑树的临界值，默认值为8，同一个桶内的链表长度达到这个值时就转化为红黑树；
static final int TREEIFY_THRESHOLD = 8;
（2）UNTREEIFY_THRESHOLD：红黑树转换为链表的临界值，默认值为6，当红黑树的节点数减少到这个变量指定的值时就退化为一个链表；
static final int UNTREEIFY_THRESHOLD = 6;
（3）MIN_TREEIFY_CAPACITY：当哈希表（table）容量table.length达到这个值，链表才会被树形化，默认值为64，并且不能小于4 * TREEIFY_THRESHOLD；如果没有这个阈值的控制，当桶内元素太多时会进行扩容而不是树形化；
static final int MIN_TREEIFY_CAPACITY = 64;
- 1.8新增数据结构：
（1）Node<K, V>：HashMap的一个静态内部类，代替了JDK1.7中的Entry来存放键值对，同时增加了Node<K,V> next变量，更有利于LinkedHashMap的实现，LinkedHashMap中的Entry就是继承自这里定义的Node。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
（2）TreeNode<K, V>：红黑树节点的数据结构，继承自LinkedHashMap中定义的LinkedHashMap.Entry<K,V>，可以追溯自己的父节点；
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V>
- 一些常量及属性初始值：
/**
* The default initial capacity - MUST be a power of two.
* 默认初始化capacity大小，值为16，capacity必须为2的次方
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* The load factor used when none specified in constructor.
* 默认负载因子，值为0.75；
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
* HashMap最大容量，必须为2的倍数并且小于等于1向右位移30位，即2的30次方；
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
重要方法
1. 构造方法：
（1）public HashMap();默认构造方法，JDK1.7中调用public HashMap(int initialCapacity, float loadFactor)，JDK1.8则只指定默认的负载因子；
// JDK 1.8
public HashMap() {
// 初始化负载因子系数为0.75，此时并未初始化HashMap
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted 其他属性均为默认值
}
// JDK 1.7
/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
// 不同于1.8,1.7在默认构造方法内就已经初始化好了HashMap
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
(2)public HashMap(int initialCapacity);指定HashMap初始容量大小；
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and the default load factor (0.75).
* 创建一个空的HashMap，传入指定的初始化容量大小，负载因子为默认值0.75f
*
* @param initialCapacity the initial capacity.
* @throws IllegalArgumentException if the initial capacity is negative.
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
(3) public HashMap(int initialCapacity, float loadFactor);同时指定HashMap初始容量大小以及负载因子值；
// JDK 1.7
/**
* @param initialCapacity the initial capacity
* initialCapacity：初始化空间大小，小于0则抛出参数非法异常，最大值不超过 static final int MAXIMUM_CAPACITY = 1 << 30;
*
* @param loadFactor the load factor
* loadFactor：负载因子大小，小于等于0或者是一个非数字参数则抛出非法参数异常;
*/
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;
threshold = initialCapacity;
init();
}
// JDK 1.8
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and load factor.
*
* @param initialCapacity 初始化空间大小，小于0则抛出参数非法异常，最大值不超过 static final int MAXIMUM_CAPACITY = 1 << 30;
* @param loadFactor 负载因子大小，小于等于0或者是一个非数字参数则抛出非法参数异常;
* @throws IllegalArgumentException if the initial capacity is negative
* or the load factor is nonpositive
*/
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);
}
(4) public HashMap(Map<? extends K, ? extends V> m);用另一个Map对象来初始化一个HashMap，负载因子为默认的0.75，初始化容量大小需要足够容纳传入的Map对象；
/**
* Constructs a new <tt>HashMap</tt> with the same mappings as the
* specified <tt>Map</tt>. The <tt>HashMap</tt> is created with
* default load factor (0.75) and an initial capacity sufficient to
* hold the mappings in the specified <tt>Map</tt>.
*
* @param m the map whose mappings are to be placed in this map
* @throws NullPointerException if the specified map is null
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false); // 如果传入m为 null，会抛出空指针异常，因此使用此构造方法之前最好做判空处理
}
2. put方法
put方法，以及后面的get方法，是HashMap使用频率最高的两个方法，put方法是将一个key-value键值对按照一定规则放到散列表对应的桶内，如果之前已经针对传入的key调用过put方法，那么就用传入的value替换老的value；
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
计算key的hash：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
从计算哈希值的源码来看，结果是依赖于key对象的hashCode()方法的。因此，如果我们自定义一个类来作为key，同时我们重写了hashCode()方法，并且这个hashCode()的逻辑与这个自定义类的其他属性相关，当这些属性的值发生改变后，同一个对象计算的hashCode()方法就可能返回不同的值。如果这个对象作为key已经进行过put操作，之后这些属性的值又被修改过，那么这个对象就可能对源码中的hash()方法产生影响，返回不同的哈希值，导致之前put的键值对可能永远不被访问到，同时如果这个HashMap的生命周期足够长，就产生了内存泄漏，因此在自定义类作为key时，这一点必须注意。
对于java.lang.Object类的public native int hashCode();方法，这是一个本地方法，具体的逻辑我还没有翻阅过源码，但是从网上得知，该方法的计算逻辑和对象的内存地址相关，虽然不能完全保证所有不同对象都返回一个不同的哈希值，但是本身这个方法的散列程度也是比较高的，所以如果自己重写hashCode()方法不能保证足够高的散列度，那么建议就不要再重写该方法了。
由以上可知，put方法的主要逻辑由putVal方法完成，putVal方法才是put方法的主体，事实上构造方法public HashMap(Map<? extends K, ? extends V> m);也是在调用此方法来完成HashMap的初始化，先贴源码：
/**
* @param hash hash for key key的hash
* @param key the key
* @param value the value to put 被放入的value
* @param onlyIfAbsent if true, don't change existing value 为true时，不替换已存在的value
* @param evict if false, the table is in creation mode. 为false，则table在创建模式
* @return previous value, or null if none 返回之前的旧的value，如果不存在就返回null
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果table还未被初始化，则直接进行初始化，一般在HashMap被定义后，首次调用put方法时被触发
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// 如果计算出来的位置没有被占用，则直接存存放
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 判断是否是同一个key
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p; // 标记冲突的头结点e
// 是否已经树形化过
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);
// 链表深度达到树形化阈值，触发树形化流程
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;
}
}
// 相同的key，用新的value替换原来的value，并返回原来的value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount; // modCount自增1，用于fast-fail
if (++size > threshold) // 达到扩容阈值，进行扩容
resize();
afterNodeInsertion(evict); // put操作时evict为true，仅当构造方法内evict为false
return null;
从源码来看，将一个键值对存入table数组，需要先计算存入的位置，计算规则是用key的hash与table容量取模tab[i = (n - 1) & hash])，如果发生哈希冲突，就先采用 链地址法 来处理冲突，如果链表长度达到了树形化阈值TREEIFY_THRESHOLD（默认8），但是table数组容量还未达到树形化阈值 MIN_TREEIFY_CAPACITY（默认64），此时就只是做数组扩容，不进行树形化：
// 链表长度达到阈值，但是数组容量还未达到阈值
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
当链表长度以及数组容量都达到阈值后，这个桶对应的链表就升华为红黑树，此后查找的时间复杂度就会从O(n)提升至O(logn)，带来更高的索引性能，源码如下：
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
// 普通节点转化为红黑树节点
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
// 树形化
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
在冲突链表树形化成红黑树时，或者树形化后进行put，remove，get等操作时，都是利用key的hashCode值来进行定位，以确定具体走左孩子或者右孩子，如下，树形化方法final void treeify(Node<K,V>[] tab)的部分代码：
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
// 利用key的哈希值进行处理
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
root = balanceInsertion(root, x);
break;
}
但是有一种极端情况，即hashCode值完全一样，并且key又未实现Comparable接口，也就是说，key既无法通过hashCode来比较大小，本身也无法比较大小，那么就无法来确定左右，此时就需要一些特殊处理，使得最终能够得到两个key对象之间的大小关系；
HashMap提供了一个static int tieBreakOrder(Object a, Object b)方法，已处理上述极端情况，通过本地方法public static native int identityHashCode(Object x)来获得一个identityHashCode，只要是两个满足==不为true的对象，这个方法的返回值就不会一样（事实上这句话只是我的臆断，该方法返回值类型为int，是有一个上限值的，即Integer.MAX_VALUE，当对象数量超过这个上限值，会出现其中两个对象的identityHashCode值一样的情况吗？由于硬件环境限制，这种场景并未能顺利测试），以此便能区分左右了；
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
以下为tieBreakOrder方法实现：
/**
* Tie-breaking utility for ordering insertions when equal
* hashCodes and non-comparable. We don't require a total
* order, just a consistent insertion rule to maintain
* equivalence across rebalancings. Tie-breaking further than
* necessary simplifies testing a bit.
*/
static int tieBreakOrder(Object a, Object b) {
int d;
if (a == null || b == null ||
(d = a.getClass().getName().
compareTo(b.getClass().getName())) == 0)
d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
-1 : 1);
return d;
}
3. resize方法
该方法完成HashMap的扩容或者初始化；
- 如果table数组为空，就执行初始化流程；
- 如果不为空，那么就执行扩容流程，扩容需要先创建一个容量为原table数组的 2 倍length的新Entry数组，然后把原数组里所有的元素都拷贝到新的数组里去，拷贝之前需要计算新的索引值；其中新建数组以及拷贝都是比较耗费资源的操作，因此初始化HashMap时尽量指定一个预估的足够大的容量值来避免或减少扩容，有利于提升系统性能；
源码：
/**
* 初始化或者table数组扩容（两倍容量扩容）
*/
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) { // 不是初始化，走扩容流程
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 扩容后的容量为原来的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 向右位移一位，达到原阈值2倍
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 容量，阈值指定初值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
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<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// 遍历原来的数组，把所有的元素都转移到新数组去
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null; // 原数组置空，以便GC
if (e.next == null) // 原数组该位置无冲突，正常存放
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode) // 原数组在这个位置上是一个红黑树
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // 原数组该位置冲突，但是还未达到树形化阈值，因此还是链表结构
// low head，low tail
Node<K,V> loHead = null, loTail = null;
// hight head，high tail
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;
}
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;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
4. get方法
返回key对应的value，否则返回null；相反的，如果返回的值为null，并非说明HashMap内不存在这样的一个键值对，有可能这个key对应的value本身就为null；
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
get方法大概逻辑：
- 如果key未能对应到一个桶，那么返回
null； - 如果对应的桶第一个元素即为传入key对应的Node，那么直接返回；
- 如果桶第一个元素并非传入key对应的Node，需要判断这个桶内是链表结构还是树形结构，链表则遍历直到找到对应的key，如果是红黑树结构，需要从根节点（
parent为空）开始向下以B+树方式进行搜索找到key；
/**
* Implements Map.get and related methods
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 先判断传入的key在map内是有相对应的value的
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)
// 从红黑树中搜索对应的key，时间复杂度O(logn)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// 还未树形化，则遍历链表，直到找到对应的key，时间复杂度O(n)
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
红黑树节点搜索的实现：
/**
* 从根节点向下查找
*/
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
if ((ph = p.hash) > h)
p = pl;
else if (ph < h)
p = pr;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
else if (pl == null)
p = pr;
else if (pr == null)
p = pl;
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
else if ((q = pr.find(h, k, kc)) != null)
return q;
else
p = pl;
} while (p != null);
return null;
}
5. remove方法
remove方法时将key对应的键值对从HashMap中移除；
// 移除指定key对应的键值对
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
以下为remove方法的实现主体：
/**
* @param hash key的哈希值
* @param key the key
* @param value remove方法传值null
* @param matchValue 值为true时，仅和传入value相等时移除，由于remove方法传入value为null，
* 因此该参数传值false，移除时对value无要求
* @param movable 为false时不熠动其他node节点，remove方法传入true
* @return 返回移除node，或者不存在对应node时返回null
*/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
// 数组不为空，找到要移除的key对应的node
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
// 哈希值相等，且与key为同一对象，记录节点node
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) { // next不为空，证明key与其他对象发生过哈希冲突，桶上至少为一个链表
if (p instanceof TreeNode) // 链表已经树形化过
// 获取key对应的红黑树节点，逻辑和get方法一致
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else { // 仅为链表，未树形化
// 遍历找到要移除的node节点
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
// 确定要移除的node，开始根据不同的数据结构移除node节点
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; // modCount自增，记录修改次数
--size; // size做相应减少
afterNodeRemoval(node);
return node; // 返回移除节点node
}
}
return null;
}
使用注意
- 当
size达到threshold时，会触发resize扩容操作，从而进行再哈希，新建数组，以及数据拷贝等比较耗费资源和性能的操作，因此尽量预判HashMap的初始size，减少或避免其resize操作； - HashMap是非线程安全的，从其设计来看，并没有发现任何并发同步处理的痕迹，若要使用线程安全的Map，可以考虑
ConcurrentHashMap； - 关于HashMap可能出现的内存泄漏，当我们定义一个类作为key，同时我们又重写了
hashCode()方法，hash值的生成依赖于该类的一个属性，这个属性对外暴露写方法，当该类的一个实例作为key已经被put进入了HashMap，在此之后与hash值生成有关的那个属性的值又被改变了，那么生成的hash值就很有可能不与put时的hash值相同，那么这个key对应的value就再也不能被检索到，刚好这个HashMap的生命周期又足够长，就造成了内存泄漏。当然，内存泄漏的场景可能不止这一种，这是我最先能想到的一种场景，若有其他场景，请各位不吝赐教！
自定义类参考如下：
class Model {
private int value;
/**
* 获取字段值： value.
*
* @return 返回字段值： value.
*/
public int getValue() {
return value;
}
/**
* 设置字段值： value.
*
* @param value value .
*/
public void setValue(int value) {
this.value = value;
}
@Override
public int hashCode() {
return value + Integer.valueOf(value).hashCode();
}
}
后话
事实上，关于HashMap的源码，我还有很多并未看懂，尤其是关于红黑树的部分，根本原因还是对于红黑树的掌握程度还很欠缺。虽然能大致说一些红黑树的东西，但是要把这个特性操作转化为代码，并且应用到不同的需求，这又完全不是一回事了。丢下一两篇关于红黑树的文章供大家一起学习（所有连接侵删）：
- 红黑树深入剖析及Java实现 ，大厂一贯作风，很容易让人理解，跟着作者思路学习即可；
- 史上最清晰的红黑树讲解（上） ，同下篇一起品尝口感更佳，非常详细的讲解；
- 史上最清晰的红黑树讲解（下）
自己还是太菜了，与大家共勉！
