目录
一、HashMap工作原理及数据结构
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {- HashMap是基于Map接口实现的哈希表，此实现了Map接口中的所有的行为操作，而且HashMap允许null的健，值。HashMap类大致相当于Hashtable，只不过它是不同步的，并且允许nulls；Map它是不能保证顺序的，特别是，它不能保证随着时间推移保持顺序不变。
- 这个实现为基本操作（get和put）提供了恒定的时间性能，假设散列函数在木桶（buckets）中适当地分散了元素。集合（Collection）的迭代需要的时间与HashMap实例的“容量”（桶的数量）和它的大小（键值映射的数量）成比例。因此，如果迭代性能很重要，要求很高，那么不将初始容量设置得太高（或负载因素过低）是非常重要的。
- HashMap是一不安全的集合，即当多线程访问的时候，同一时刻如果无法保证只有一个线程修改HashMap,则会毁坏HashMap，则抛出ConcurrentModificationException.
- jdk8 之前的HashMap 内部是基于一个数组来实现的，数组中的每个元素称为一个桶(bin、bucket)，单个木桶是由单向链表组成。当数组中被占用的桶的数量超过了装填（加载）因子和数组容量设定的阈值后，会对数组进行扩容，容量将扩展为原来的2倍。哈希表中所有的 Entry 会被重新散列到新的位置中。
-
UML继承实现关系：
二、HashMap源码分析（jdk8版本的源码）
1、了解内部属性
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
// 支持可序列化
private static final long serialVersionUID = 362498820763181265L;
//构建的时候默认的初始化容量=16，使用位移，2进制。
//因为2进制效率更高
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//这个是最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//这个就是上文所说的默认的填充因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 当桶(bucket)上的结点数大于这个值时会转成红黑树
static final int TREEIFY_THRESHOLD = 8;
// 当桶(bucket)上的结点数小于这个值时树转链表
static final int UNTREEIFY_THRESHOLD = 6;
//桶结构转化为红黑树的时候，table最小容量
static final int MIN_TREEIFY_CAPACITY = 64;1、HashMap有2个参数影响它的性能：初始容量和负载因数（initial capacity and load factor）。
(1)、initial capacity：HashMap创建的时候初始化容量，即木桶的数量。
(2)、load factor：负载因子是一种衡量哈希表在其容量自动增加之前的完整程度的度量。
当哈希表中的条目数超过负荷因子和当前容量的乘积时，哈希表内部数据结构将被重建，这样哈希表的bucket数量扩大两倍。
2、源码中默认的负载因子是设置成（0.75）在时间和空间成本之间提供了一个很好的权衡。更高的值减少了空间开销，但是增加了查找成本（反映在HashMap类的大多数操作中，包括get和put）。
3、
/**
* 下一次扩充的长度值，如果我们构造HashMap的时候，没有指定初始化的容量（capacity）,
* 利用的是默认的构造方法，那么这个值是默认的capacity或者也有可能是0
* The next size value at which to resize (capacity * load factor).
*
* @serial
*/
// (The javadoc description is true upon serialization.
// Additionally, if the table array has not been allocated, this
// field holds the initial array capacity, or zero signifying
// DEFAULT_INITIAL_CAPACITY.)
int threshold;
2、HashMap的构造函数，初始化
上面是HashMap创建的几种方式：
（（1）、HashMap(): 构建一个空的HashMap默认初始化容量16，默认加载因子0.75.其他的 属性默认。
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
（2）、HashMap(int):构建指定初始化容量的，默认加载因子0.75的HashMap。
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
（3）、HashMap(int,float)构建指定的加载因子，指定的初始化容量.
public HashMap(int initialCapacity, float loadFactor) {
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;
//调整大小的下一个大小值(capacity * loadFactory)
this.threshold = tableSizeFor(initialCapacity);
}
//又是位移的形式，2的capacity次方，如果容量不够的话则会自动增加容量
//但是容量不会大于MAXIMUM_CAPACITY。
//这里解析下tableSizeFor(int cap):
//>>>是无符号右移操作，|是位或操作，经过五次右移和位或操作可以保证得//到大小为2^k-1的数
0 0 0 0 1 ? ? ? ? ? //n
0 0 0 0 1 1 ? ? ? ? //n |= n >>> 1;
0 0 0 0 1 1 1 1 ? ? //n |= n >>> 2;
0 0 0 0 1 1 1 1 1 1 //n |= n >>> 4;
//表在第一次使用时初始化，并在必要时进行调整。当分配时，长度是=2的n幂。
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;
}3、HashMap的内部结构
（1）、transient Node<K,V>[] table;
// Node是一个单向链表的一个结点，是HashMap的一个静态的内部类,实现了Map.Entry<K,V>接口。源码如下。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key; //当前节点的key值
V value; //当前节点的value值
Node<K,V> next; //下一个Node节点
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);
}
//为value设置新值，并返回oldValue
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;
}
}
以上的源码Node，其实就是单向链表的一个节点，包括了健，值，下个节点的引用。hashCode值：这个Node节点的hashCode值，是key和value分别的hashCode值的异或关系。
（2）、红黑二叉树TreeNode<K,V>
TreeNode<K,V> extends LinkedHashMap.Entry<K,V>
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // 父节点
TreeNode<K,V> left; //左子树
TreeNode<K,V> right; //右子树
TreeNode<K,V> prev; //上一个同级节点
boolean red;//是否红色属性
//构造函数
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
.........
}下面说下什么是红黑树，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。
红黑树的特征：
- 、根节点是黑节点。
- 、每个节点不是黑色就是红色。
- 、如果一个节点是红色的，则它的子节点必须是黑色的。
- 、每个为空(NIL或NULL)的叶子节点是黑色。
- 、没有一条路径会比其他路径长出俩倍。（平衡的二叉树）。
- 、左子树上所有结点的值均小于或等于它的根结点的值。
- 、右子树上所有结点的值均大于或等于它的根结点的值。
- 、左、右子树也分别为二叉排序树。
、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
红黑树的应用比较广泛，主要是用它来存储有序的数据，它的时间复杂度是O(lgn)，效率非常之高。
4、HashMap操作
我们已经分析了HashMap中2种存储数据的结构。但什么时候去使用，如何使用这些数据结构存储数据，访问数据，删除数据呢？带着疑问继续看源码；默认构造HashMap的时候其实是没有table数组去分配空间，而是第一次put的时候才会分配，满足扩容条件resize方法。
我们先看往HashMap中存数据：
（1）、put 插入数据
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
/**先定义一个临时Node节点数组tab，p是单个节点的变量，n表示节点数组表的长度，i表示tab数组索引位置*/
Node<K,V>[] tab; Node<K,V> p; int n, i;
/**如果table是刚初始化（null）,或者table的长度为0，则进行扩大数组tab的长度*/
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;/** 跟踪resize（）进去看源码*/
if ((p = tab[i = (n - 1) & hash]) == null)
/** 通过hash值算出木桶的位置，如果该位置为null，则创建一个木桶节点*/
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
/** 如果木桶中的要存的位置的该节点的hash值和key都分别相等
则把要该位置的已经存在的值（old）的node节点引用赋值给一个临时的变量e*/
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);
/** 如果节点数量达到链表转化为红黑树的阀值，则转化为红黑二叉树*/
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;
/**遍历桶中的链表，与前面的e = p.next组合，是可以遍历链表的条件*/
p = e;
}
}
/**
* 如果在桶中找到key值、hash值与插入元素相等的结点。
* 新的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;//表的结构被修改的次数增加
if (++size > threshold)
resize();/** 大于阀值来扩容*/
afterNodeInsertion(evict);
return null;
}总结：
1、针对以上put函数的源码，我们可以看出Hash表通过key的hashcode()得到的hash值，然后 hashCode%n,取余，就是桶数组中所在的位置索引。
2、上面的代码是如何实现的？
(n - 1) & hash
就是取模的操作其中n = tab.length；hash = hash(key)
Hash():
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
首先获取对象的hashCode()值，然后将hashCode值右移16位，然后将右移后的值与原来的hashCode做异或运算，返回Hash值结果。
n必须是2^m，因而(n-1)的二进制表示为0...011...11 的形式，位与操作后保留了 h 的低位，实际上就是 h%n。只是位操作相比于取模的操作更加高效。这也解释了为什么必须要求数组长度是2的幂次方，因为只有这样才能保证使用位与取模的正确性。再回过头来看看 hash()
操作，因为映射时只保留了低位信息，两个值如果低位相同很可能会发生碰撞；而将高位和低位异或，引入了高位的信息，减少了碰撞的概率。
3、hashMap支持null key，null value，key==null的时候，其hash值为0；
（2）、resize 扩容
/**
* 初始化或者对表的大小进行加倍，如果为null,则按初始容量目标分配。
* 否则，因为我们使用的是2的幂次方扩充容量的，每个bin中的元素必须保持在相同的索引，
* 或者在新表中以两倍偏移量移动。
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the table
*/
final Node<K,V>[] resize() {
/**对当前的table进行扩容*/
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
/** newCap:定义一个新的临时容量变量，newThr:定义个新的临时的threshold*/
int newCap, newThr = 0;
/**如果再扩充前的容量是大于0的*/
if (oldCap > 0) {
/**大于最大的MAXIMUM_CAPACITY*/
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;/**则把threshold = 21亿多（4个字节做大值）*/
return oldTab;/**直接返回*/
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)/**如果位移1位，也就是翻倍（oldCap*2）,仍然没有大于MAXNUM*/
newThr = oldThr << 1; /** newThr = oldCap*2 = threshold*2*/
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;/** AAA:初始化的capacity 被赋值给newCap*/
else { // zero initial threshold signifies using defaults
/** 这种情况就是构造HashMap的时候，threshold初始化是0，第一次put数据resize，则我们就给
* 给newCap赋值默认的初始化的容量16，newThr = 16*0.75
* */
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
/**如果上面程序走的是AAA分支的话，那么newThr没有定位一个合适的值，此处就是给newThr赋合法值*/
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"})
/** 创建节点数组，并且ru'guo赋值给table*/
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
/** 如果扩充前oldTab的值不是null值，那我们将进行把之前的旧值赋值到对应的newTab中*/
if (oldTab != null) {
/**遍历循环oldCap*/
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null; /** 如果j位置有节点元素，则取出该元素e，并且把数组中的该位置的node节点赋值null*/
if (e.next == null)/** 如果下个节点没有数据了（也就是链表的尾部），则把e,放在newTab位置为e.hash & (newCap - 1) 的地方*/
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)/** 如果是红黑树（点进split方法继续跟踪），重新映射，对红黑树进行split*/
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
/** 如果该节点是链表的存储
* 如果你对链表的结构，和java操作链表不会,那很难看懂
* */
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
/** 维持原来的链表的节点顺序进行rehash*/
do {
next = e.next; /** 当前节点指向的下一个节点地址*/
/** 原索引*/
if ((e.hash & oldCap) == 0) {/** e.hash & oldCap 这个计算的值，是节点数组的位置索引*/
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {/** 原所以加上oldCap*/
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
/** 原索引放在bucket里*/
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
/** 原索引+ oldCap放在bucket里*/
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
/**
* 总结：
* 经过rehash之后，元素的位置要么在原来的位置，要么在原来的位置
* 再移动2次幂。
* */
}
}
}
}
return newTab;
}
总结：在jdk1.8中，resize方法是在hashmap中的键值对大于阀值时或者初始化时，就调用resize方法进行扩容，都是扩展2倍 扩展后Node对象的位置要么在原位置，要么移动到原偏移量两倍的位置。
（0）、我们在 HashMap 的构造函数中并没有看到为 table 数组分配空间的语句，因为这里采用了延迟加载的方式，直到第一次调用 put 方法时才会真正地分配数组空间。
（1）、HashMap使用了基于（数组和单向链表）的哈希表的结构，数组中每一个元素都是一个链表，数组的初始化的长度是16，把数组中的每一格称为一个桶(bin或bucket)。当数组中已经被使用的桶的数量超过容量和加载因子的积，会进行扩容resize操作。
（2）、由于每一个桶（数组的单个元素）中都是一个单向链表，hash 相同的键值对都会作为一个节点被加入这个链表，当桶中键值对数量过多时会将桶中的单向链表转化为一个树。通过TREEIFY_THRESHOLD、UNTREEIFY_THRESHOLD和MIN_TREEIFY_CAPACITY来控制转换需要的阈值。
当然如果链表node的数量>8的时候，转化成红黑树。
如果红黑树的node的数量<6的时候，转化成链表。
(4)、如果只用单向链表的方式存储，那么查找数据的话处理哈希碰撞这种情况会对性能产生严重影响。时间复杂度为O(0)->O(n),而如果用红黑树的话时间复杂度也就只有O(log n).但是空间占用比较高。一般链表中的node的数量达到一定条件才会转换为红黑二叉树，这条件不会低。
（3）、get 获取查找数据
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;
}以上源码可以意思大概是通过key算出，当初存的位置，然后从第一项开始查，如果没有查到，则通过f ((e = first.next) != null) 查询下一个节点，如果我红黑树节点，就在红黑树中找，否则就在链表中查到。
- 、remove删除
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;
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;
//p指向bin中的第一个Entry
//node指向目标Entry
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
//在红黑树中查找目标Entry
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {//在单链表中查找目标Entry
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 TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
/**移除单链表的第一个节点*/
else if (node == p)
tab[index] = node.next;
/**不是单链表的第一个节点*/
else
p.next = node.next;
++modCount; /**增加修改计数器的次数*/
--size; /**修改大小*/
afterNodeRemoval(node); /**回调*/
return node;
}
}
return null;
}总计：通过以上源码，我们基本是是完全掌握了hashMap的工作流程，及其工作原理。
其中红黑树的二叉树插入操作没有做重点解析。后面会单独拿红黑树二叉树这块写一篇文章。红黑树的实现比较复杂，文中并没有作具体的分析。如果需要遍历所有的Entry，可以将红黑树也当作单向链表处理，因为 HashMap 中红黑树的节点中也维护了一个 next 引用。