作为一种最为常用的容器，同时也是效率比较高的容器，HashMap当之无愧。所以自己这次jdk源码学习，就从HashMap开始吧，当然水平有限，有不正确的地方，欢迎指正，促进共同学习进步，就是喜欢程序员这种开源精神。(好吧，第一篇博客有点紧张)
一. HashMap结构
HashMap在jdk1.6版本采用数组+链表的存储方式，但是到1.8版本时采用了数组+链表/红黑树的方式进行存储，有效的提高了查找时间，解决冲突。这里有一篇博客写的非常好，HashMap的结构图也画的非常清楚，鼎力推荐一下杭州Mark的HashMap源码分析。虽然是基于jdk1.6的，但是换成jdk1.8，只要链表长度大于门限时，换成红黑树就好了， 我就不具体解释HashMap的具体结构了。
二.HashMap 定义
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
继承自AbstractMap,这是一个抽象类，定义了并且实现了Map接口的基本行为，但是基本上HashMap都对其进行了重写覆盖，采用了自己更高效的方式。AbstractMap是我们自己编写Map时，可以用到的基类。(好吧，来自JAVA编程思想，还没有自己写过Map)
实现了Map接口,这里其实有一个疑问，为什么在AbstractMap中已经明显实现Map接口的情况下，还要显著在实现Map接口？这种设计方式的原因？
其余都是标记接口。
三.重要的field属性
//默认的初始化数组大小为16，为啥不直接写16（jdk1.6是这么干的）啊？confused
//这里必须是2的整数幂，
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4
//最大存储容量
static final int MAXIMUM_CAPACITY = 1 << 30
//默认装载因子，我理解的就是所占最大百分比，即当超过75%时，就需要扩容了
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//这是jdk1.8新加的，这是链表的最大长度，当大于这个长度时，就会将链表转成红黑树
static final int TREEIFY_THRESHOLD = 8; //table就是存储Node 的数组，就是hash表中的桶位，后面会重点介绍Node
transient Node<K,V>[] table;
//实际存储的数量，则HashMap的size()方法，实际返回的就是这个值，isEmpty()也是判断该值是否为0
transient int size;
//HashMap每改变一次结构，不管是添加还是删除都会modCount+1，主要用来当迭代时，保持数据的一致性（不知道这么理解正确么？）
//因为每一次迭代，都会检查modCount是否改变是否一致，不一致就会抛出异常。这也是为什么迭代过程中，除了运用迭代器的remove()方法外，不能自己进行改变数据
//fast-fail机制
transient int modCount; //扩容的门限值，当大于这个值时，table数组要进行扩容，一般等于（cap*loadFactor）
int threshold;
//装载因子
final float loadFactor;
四.HashMap构造器
HashMap共有四种构造器，常用的有三种，主要分为无参构造器，应用默认的参数；指定初始化容量的构造器；将原有Map装进当前HashMap的构造器。
1.无参构造器
//这就是一个默认的方式，潜在的问题是初始容量16太小了，可能中间需要不断扩容的问题，会影响插入的效率，当看到后面resize()方法时，可以很明显的看到这个问题
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
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)//这里就重新定义了扩容的门限
}
可以看到此时threshold被tableSizeFor()方法重新计算了，那我们研究一下tableSizeFor方法
//tableSizeFor的功能主要是用来保证容量应该大于cap,且为2的整数幂，但是这段代码没有完全看懂
//我理解了一下就是将最高位依次跟后面的进行或运算，将低位全变成1，最后在n+1,从而变成2的整数幂
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;
}
不得不说写源码的都是追求完美的大神，下面是jdk1.6的实现方式，就是简单的循环，可以看到采用位运算后效率明显提高了
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
这里可能还有一个疑问，明明给的是初始容量，为什么要计算门限，而不是容量呢？其实这也是jdk1.8的改变，它将table的初始化放入了resize()中，而且压根就没有capacity这个属性，所以这里只能重新计算threshold，而resize()后面就会根据threshold来重新计算capacity，来进行table数组的初始化，然后在重新按照装载因子计算threshold，有点绕，后面看resize()源码就清楚了。
3.仅仅指定容量
//下面这种方式更好，所以当知道所要构建的数据容量大小时，最好直接指定大小，可以减除不停扩容的过程，大幅提高效率
public HashMap(int initialCapacity){
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
4.将已有Map放入当前map中
//这种方式是将已有Map中的元素放入当前HashMap中
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
//这里就是一个个取出m中的元素调用putVal,一个个放入table中的过程。
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
五.重要的方法
1.Node 内部类
可以看到前面table就是Node数组，Node是什么？它是一个HashMap内部类（改名字了，jdk1.6就叫Entry），继承自 Map.Entry这个内部接口，它就是存储一对映射关系的最小单元，也就是说key，value实际存储在Node中。
//可以看出虽然这里不叫Entry这个广泛应用的名字了，但是与jdk1.6比，还是没有什么大的变化
//依然实现了Map.Entry这个内部接口，换汤没换药
//其实就是最基本的链表实现方式
static class Node<K,V> implements Map.Entry<K,V> {
//可以发现，HashMap的每个键值对就是靠这里实现的，并没有很高大上
//并且键应用了final修饰符，所以键是不可改变的！
final int hash;//这里这个一般保存键的hash值
final K key;
V value;
//next 应用于一个桶位中的链表结构，表示下一个节点键值对
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; }
//键的hashcode与值的hashcode异或，得到hash值，并且这里应用的是最原始的hashCode计算方式，Objects
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;
//键和值都eauals，才行，而且是Objects.equals,只能是同一对象
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
2.put方法
//可以看到是调用的putVal的方法，并且计算了key的hash值
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// Computes key.hashCode() and spreads (XORs) higher bits of hash
/** to lower. Because the table uses power-of-two masking, sets of
* hashes that vary only in bits above the current mask will
* always collide. (Among known examples are sets of Float keys
* holding consecutive whole numbers in small tables.) So we
* apply a transform that spreads the impact of higher bits
* downward. There is a tradeoff between speed, utility, and
* quality of bit-spreading. Because many common sets of hashes
* are already reasonably distributed (so don't benefit from
* spreading), and because we use trees to handle large sets of
* collisions in bins, we just XOR some shifted bits in the
* cheapest possible way to reduce systematic lossage, as well as
* to incorporate impact of the highest bits that would otherwise
* never be used in index calculations because of table bounds.
*/
static final int hash(Object key) {
int h;
//这里可以看到key是有可能是null的，并且会在0桶位位置
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里hashCode的计算也进行了改进，取得key的hashcode后，高16位与低16位异或运算重新计算hash值。
下面重点看一下put方法实现的大拿，putVal方法。
/**
* 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<K,V>[] tab; Node<K,V> p; int n, i;
//table 没有初始化
if ((tab = table) == null || (n = tab.length) == 0)
//可以看到table的初始化放在了这里，是通过resize来做的，后面会分析resize()
n = (tab = resize()).length; //这里就是HASH算法了，用来定位桶位的方式，可以看到是采用容量-1与键hash值进行与运算
//n-1,的原因就是n一定是一个2的整数幂，而(n - 1) & hash其实质就是n%hash,但是取余运算的效率明显不如位运算与
//并且(n - 1) & hash也能保证散列均匀，不会产生只有偶数位有值的现象
if ((p = tab[i = (n - 1) & hash]) == null)
//当这里是空桶位时，就直接构造新的Node节点，将其放入桶位中
//newNode()方法，就是对new Node(,,,)的包装
//同时也可以看到Node中的hash值就是重新计算的hash(key)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//键hash值相等，键相等时，这里就是发现该键已经存在于Map中
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);
//当该桶位为链表结构时，进行链表的插入操作，但是当链表长度大于TREEIFY_THRESHOLD - 1，就要将链表转换成红黑树
else {
//这里binCount记录链表的长度
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;
}
}
//替换操作，onlyIfAbsent为false
//所以onlyIfAbsent,这个参数主要决定是否执行替换，当该键已经存在时，
//而下面的方法则是一种不替换的put方法，因为onlyIfAbsent为true
//这里其实只是为了给putIfAbsent方法提供支持，这也是jdk1.8新增的方法
// public V putIfAbsent(K key, V value) {
// return putVal(hash(key), key, value, true, true);
// }
//
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;
}
下面在看一下扩容方法resize(),jdk1.8的resize相比以往又多了一份使命，table初始化部分，也会在这里完成。
/**
* 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.
*/ 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;
}
//采用二倍扩容
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//可以看到新的门限也是变为二倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
//这里就是构造器只是给了容量时的情况，将门限直接给成新容量
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//这个是采用HashMap()这个方式构造容器时，可以看到就只是采用默认值就行初始化
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
//这里可以看出门限与容量的关系，永远满足loadFactor这个装载因子
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//更新门限到threshold field
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//好吧，找它一圈终于找到table的初始化了
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//这里就是当原始table不为空时，要有一个搬家的过程，所以这里是最浪费效率的
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
//先释放，解脱它，而不是等着JVM自己收集，因为有可能导致根本没有被收集，因为原始引用还在
oldTab[j] = null;
//当该桶位链表长度为1时，
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 { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//这里又是一个理解不太清楚的地方了
//(e.hash & oldCap) == 0，应该是表示原hash值小于oldcap，则其桶位不变，链表还 是在原位置
//若>0,则表示原hash值大于该oldCap，则桶位变为j + oldCap
//从结果来看等效于e.hash & (newCap - 1)，只是不知道为何这样计算
//而且与jdk1.6比，这里链表并没有被倒置，而jdk1.6中，每次扩容链表都会被倒置
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;
}
其实HashMap put方法中最重要的就是putVal和resize()这两个方法了，搞懂他们，就基本搞懂HashMap的存储方式了，因为get方法就是一个反向的过程。
putAll方法就easy了
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}
3.get方法
get方法同样也是最常用的方法（不可能光存不取啊），可以看到通过getNode方法获得节点后，直接取出Node的value属性即可。
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;
//这里就是hash算法查找的过程，可以看到与put方法是一致的
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);
}
}
//值得注意的是当查找不到的时候是返回null的
return null;
}
相比于插入由于少了扩容的部分，get查找简化了很多，这里也能看到hash算法的精髓，快速定位查找功能，不需要遍历就能查找到。
//containsKey，查询是否存在某个键，getNode()大法好
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
4.remove方法
//根据键，删除某一个节点，返回value值
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**
* Implements Map.remove and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to match if matchValue, else ignored
* @param matchValue if true only remove if value is equal
* @param movable if false do not move other nodes while removing
* @return the node, or null if none
*/
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;
//这里的node就是 所查找到的节点
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)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
//这里p保存的是父节点，因为这里涉及到链表删除的操作
p = e;
} while ((e = e.next) != null);
}
}
//这里可以看出matchValue这个参数的作用了
//当matchValue为false时(即这里我们remove方法所用的)，直接短路后面的运算，进行删除操作，而不用关注value值是否相等或者equals
//而matchValue为true时，则只有在value值也符合时，才删除
//而jdk1.8也是给了重载方法，应用于当key键与value值同时匹配时，才进行删除操作
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
//movable这个参数竟然是应用在了树删除上，可以再看一看
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//表示该节点就是链表的头节点，则将子节点放进桶位
else if (node == p)
tab[index] = node.next;
//删除节点后节点，父节点的next重新连接
else
p.next = node.next;
//删除操作也是要记录进modCount的
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
这里matchValue这个参数设置很巧妙，巧妙的解决了这个方法的重用问题，当然源码里还有很多很精巧的设计。
//这是jdk1.8新增的方法，可以看到只有matchValue改变成了true
//只有键和值都匹配才删除
public boolean remove(Object key, Object value) {
return removeNode(hash(key), key, value, true, true) != null;
5.replace方法
似乎是jdk1.8新增的方法,但是有了前面的理解，这个方法自己写也能做出来。
可以有两种方案，一种是采用putVal的方法，因为很明显putVal是能够替换的，但是这里就涉及到了size,和modCount这两个field的变化了，也是要注意的。
另一种是getNode得到节点，然后替换，所以采用了getNode这个方法。
//分为两种，一种是死切摆列的非要key和 value都匹配上，才换
//另一种就是键匹配就换
public boolean replace(K key, V oldValue, V newValue) {
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;
}
public V replace(K key, V value) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) != null) {
V oldValue = e.value;
e.value = value;
afterNodeAccess(e);
return oldValue;
}
return null;
}
可以看出jdk1.8考虑了更多的应用场景。
5.其他方法
/**
* Removes all of the mappings from this map.
* The map will be empty after this call returns.
*/
public void clear() {
Node<K,V>[] tab;
modCount++;
if ((tab = table) != null && size > 0) {
size = 0;
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}
/**
* Returns the number of key-value mappings in this map.
*
* @return the number of key-value mappings in this map
*/
public int size() {
return size;
}
/**
* Returns <tt>true</tt> if this map contains no key-value mappings.
*
* @return <tt>true</tt> if this map contains no key-value mappings
*/
public boolean isEmpty() {
return size == 0;
}
六.总结
通过分析HashMap源码，可以很好的领会Hash算法的实现原理，以及实现中的各种问题，同时对于链表的操作也是一个非常好的提高过程。
这里也发现，其实这次学习笔记，只是记录了最基本的增删改查，而红黑树，以及entryset，迭代器等等都还没有进行介绍，这也是留在后面有时间要重点介绍的。同时自己的Hash算法基础也要过过关了。
这是第一篇博客，是对自己学习过程的一个记录，也是一个督促。最后再感谢杭州.Mark的那篇博文，对自己分析HashMap有一个非常大的借鉴意义。