HashMap是使用频率超级高的java容器,其之所以使用频率高是因为它的get和put的效率极其高,可以在o(1+a)的时间内完成get和put操作。
HashMap还有一个兄弟类叫HashTable,他们基本基本提供相同的功能,他们之间的不同主要是HashTable中的方法都采用了同步策略,并且不支持null键,相反,HashMap则不是线程安全的且支持null键null值。
接下来开始一步步分析HashMap的源码。
首先,看下HashMap的继承体系结构.
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
HashMap继承了AbstractMap这个抽象类,并且实现了Map、克隆和序列化接口。
首先看看,存在那些关键的常量
//默认的初始容量,这里有一点注意的是,HashMap的桶的个数都保持在2的幂次,如果16=2^4 //如果确定要存储多个简直时,建议指定容器的初始容量的大小,避免自动扩容造成的性能浪费 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大允许的桶的个数,为Integer.MAX_VALUE / 2 + 1 static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的装载因子,这个参数是用来平衡时间和空间上的开销,装载因子越大,空间利用率越高,但是查询效率就越低 //装载因子越小,空间利用率越低,查询效率就越高,0.75f是一个合理的装载因子,一般情况无需改变 static final float DEFAULT_LOAD_FACTOR = 0.75f;
//这是javaJDK1.8新增的阈值,是决定是否将链表树化的关键,如果一个桶中的Node链表的长度超过了8,那么就会将链表转化为红黑树 //因为随着HashMap中存入的数据越来越多,桶中的链会越来越长,那就就会造成查找效率低下,如果桶中的结点多于8个,那么就将链表 //转化为红黑树,这样就能将查找效率提高到o(logN)而不是o(n) static final int TREEIFY_THRESHOLD = 8;
//如果桶中的数据少于6个,那么就重新将红黑树转换成为链表 static final int UNTREEIFY_THRESHOLD = 6;
//最小的树化的桶数,如果哈希表中桶数<64,那么就进行resize,否则进行树化 //这个值最少应该是4 * treeify threshold,这样就能减少resize和treeify的冲突 static final int MIN_TREEIFY_CAPACITY = 64;现在咱们知道了,新的HashMap由于在底层维护了一个新的数据结构-红黑树,即使在非常大量的数据下也能保持良好的查找速度。接下来看看,看看HashMap底层的节点是如何维护的。可以看出JDK1.8之后将Entry改成了Node,这样更加符合连标和红黑树中元素的语义。两个节点只有当键和值都相等时才是等价的。
static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; //其他方法省略 }
好吧,说了这么多,用一张网上的图来形象的描述一下HashMap的逻辑数据结构吧。
哈哈哈,是不是感觉很Q很萌。
说了这么多,那么HashMap底层的哈希策略是如何的呢?
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
哈哈,就是这样的,简单吧,虽然看起来很简单,但是里面确实存在很大学问的,核心思想就是通过右移,来使低位尽量不同,来防止那些比较差劲的hashCode()方法造成的节点分布不均匀的情况。
有了哈希策略了,除了哈希策略有讲究之外,咱们再看看其底层的Capacity的计算方法。
这个方法通过右移,使得计算出来的结果都是不小于cap的的2的幂次方,不信大家动手计算试试看。至于为什么桶的容量都是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; }
首先,因为HashMap的桶定位是基于取模的,如果使用2的幂次方的容量,可以用hash&(n-1)这样高效的位运算来代替hash%n。更重要的是,他能更好的使节点均匀的分布在各个桶中,分布的越均匀,查询的效率就会越高。
下面来到了HashMap的构造器。
/** 初始化装载因子和resize的阈值,大家注意了initialCapacity可能不是在这里初始化的 */
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(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }
/** 无参构造器 */ public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted }
/** 直接通过一个Map来进行初始化 */ public HashMap(java.util.Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false);//第二个参数false标示是第一次往HashMap里面添加内容,否则为true }
前面三个构造器没什么好说的,从第四个构造器说起。
在初始化装载因子以后,就调用了一个putMapEntries()的方法,走进去瞧一瞧看一看。
final void putMapEntries(java.util.Map<? extends K, ? extends V> m, boolean evict/**标示是第一次,first time*/) { int s = m.size(); if (s > 0) { /** 如果是第一次传值,你的table必然还没有初始化,那好吧,那就初始化吧 */ if (table == null) { float ft = ((float)s / loadFactor) + 1.0F;//这里的用意不是很明显,估摸着能够更快的探测是否到最大容量,因为最大容量为Integer.MAX_VALUE / 2 + 1 int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY); if (t > threshold)//threshold还没初始化仍然为0值 threshold = tableSizeFor(t);//初始扩容阈值为 }//$到这里为止,初始化了扩容的阈值,table仍然为null,也就是还没有初始化 /** 如果不是第一次添加,并且要添加的内容本身就超过了扩容的阈值,那肯定是要扩容的 */ else if (s > threshold) resize(); /** 无论你是否已经初始化了table,这里都要开始往HashMap里面添键值对了,这里有一个方法叫putVal,这才是真正的push方法 */ 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); } } }
此时此刻,真的像洋葱一样,let's进入到putVal()。
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还没初始化,或者table里面还是空的,憋说话,resize(),resize()返回的是一个更大的table,并且oldTable里面的数据已经放进去了 */ if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; /** 此时此刻往新的tab里面添加新元素吧,如果桶是空的,那么直接丢进去一个Node */ if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); /** 否则,对应的桶里面有元素了,怎么办,往下看...*/ else { HashMap.Node<K, V> e; K k; //如果当前要放入的哈希值与当前的这个元素的哈希值一样,并且键也是一样的,那么就替换吧 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; //否则,如果新加入元素的时候,这个桶里面的结构不是链表而是树结构,那么就按照插入红黑树节点的方式去放入值 else if (p instanceof HashMap.TreeNode) e = ((HashMap.TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value); //否则就只可能是普通的元素,那么就按平常的方法插入元素即可 else { for (int binCount = 0; ; ++binCount) { //如果当前节点的next没有了,那么就把节点插到当前节点的的后面 if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); //插入节点之后达到了树化的阈值,那么就将整个桶树化 if (binCount >= TREEIFY_THRESHOLD - 1) treeifyBin(tab, hash); break; } //如果当前节点hash和键和p的哈希值一样而键也一样,那么就直接退出 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; //否则pointer指向下一个链表节点 p = e; } } //否则e找到了匹配到的元素,那么就看看是否要替换旧值,然后替换掉 if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount;//这个modCount的是为了快速检测迭代修改的错误的,也就是在迭代时,你不能删除和添加,否则就抛出ConcurrentModificationException //看是否需要扩容 if (++size > threshold) resize(); //这里是为LinkedHashMap写的钩子函数,666 afterNodeInsertion(evict); //插入成功,返回null return null; }
那么说了这么久,再看看究竟是如何扩容的把?
/** 扩容 */ final HashMap.Node<K,V>[] resize() { HashMap.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成2倍 */ 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 //默认容量在这里设置为16 newCap = DEFAULT_INITIAL_CAPACITY; //新的扩容阈值为16 * 0.75 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"}) HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap]; //在这里终于初始化了table,真是用心良苦啊,接下来新的table和久的table是一个引用了 table = newTab; //新的table生成之后,将旧的table里面的元素装进新的table里面,也就是重新哈希,这里原来在一个桶中的元素会被分开,如果原来一个桶 //的元素哈希之后还在一个桶,那么我们说这次重哈希是没有意义的。 if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { HashMap.Node<K,V> e; if ((e = oldTab[j]) != null) { oldTab[j] = null; if (e.next == null) newTab[e.hash & (newCap - 1)] = e; else if (e instanceof HashMap.TreeNode) ((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order HashMap.Node<K,V> loHead = null, loTail = null; HashMap.Node<K,V> hiHead = null, hiTail = null; HashMap.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;//返回新table的引用,同时他也是HashMap的table引用 }
从这里来说,我们已经讲完了基本的初始化和put操作是如何进行的。接下来看看树化是个什么样的过程。
final void treeifyBin(HashMap.Node<K,V>[] tab, int hash) { int n, index; HashMap.Node<K,V> e; /** 如果桶的个数还不超过64,那么就不会树化,还会继续扩容充哈希 */ if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize(); /** 树化其实就是把所有的连标节点封装成为TreeNode然后将,然后使封装的TreeNode形成一棵二叉树 */ else if ((e = tab[index = (n - 1) & hash]) != null) { HashMap.TreeNode<K,V> hd = null, tl = null; do { HashMap.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); /** 如果二叉树的跟节点不是null的,那么就开始红黑树化,这里才是真正的树化,前面形成的一直是简单的二叉搜索树 */ if ((tab[index] = hd) != null) hd.treeify(tab); } }
讲完了put方法,下面看下get方法。
public V get(Object key) { HashMap.Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; }
继续走进getNode。
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) { /** 总是和第一个节点进行比较,如果第一个节点就和要查询的节点匹配,那么就将第一个绩点返回 */ 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 { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; //get and return } while ((e = e.next) != null); } } return null; //referring not found }这里为止,我们了解到了JDK1.8对HashMap的一些优化。哈哈,这是我的第二篇博客啦。