一、HashMap的定义和构造函数
<span style="color:#000000"><code><span style="color:#000088">public</span> <span style="color:#000088">class</span> <span style="color:#4f4f4f">HashMap</span><<span style="color:#4f4f4f">K</span>,<span style="color:#4f4f4f">V</span>>
<span style="color:#000088">extends</span> <span style="color:#4f4f4f">AbstractMap</span><<span style="color:#4f4f4f">K</span>,<span style="color:#4f4f4f">V</span>>
<span style="color:#000088">implements</span> <span style="color:#4f4f4f">Map</span><<span style="color:#4f4f4f">K</span>,<span style="color:#4f4f4f">V</span>>, <span style="color:#4f4f4f">Cloneable</span>, <span style="color:#4f4f4f">Serializable</span></code></span>
HashMap继承自AbstractMap,AbstractMap是Map接口的骨干实现,AbstractMap中实现了Map中最重要最常用和方法,这样HashMap继承AbstractMap就不需要实现Map的所有方法,让HashMap减少了大量的工作。
而在这里仍然实现Map结构,没有什么作用,应该是为了让map的层次结构更加清晰
HashMap的成员变量
int DEFAULT_INITIAL_CAPACITY = 16:默认的初始容量为16
int MAXIMUM_CAPACITY = 1 << 30:最大的容量为 2 ^ 30
float DEFAULT_LOAD_FACTOR = 0.75f:默认的加载因子为 0.75f
Entry< K,V>[] table:Entry类型的数组,HashMap用这个来维护内部的数据结构,它的长度由容量决定
int size:HashMap的大小
int threshold:HashMap的极限容量,扩容临界点(容量和加载因子的乘积)
谨记这些成员变量,在HashMap内部经常看到
HashMap的四个构造函数
public HashMap():构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap
public HashMap(int initialCapacity):构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap
public HashMap(int initialCapacity, float loadFactor):构造一个带指定初始容量和加载因子的空 HashMap
public HashMap(Map< ? extends K, ? extends V> m):构造一个映射关系与指定 Map 相同的新 HashMap
这里有两个很重要的参数:initialCapacity(初始容量)、loadFactor(加载因子),看看JDK中的解释:
HashMap 的实例有两个参数影响其性能:初始容量 和加载因子。
容量 :是哈希表中桶的数量,初始容量只是哈希表在创建时的容量,实际上就是Entry< K,V>[] table的容量
加载因子 :是哈希表在其容量自动增加之前可以达到多满的一种尺度。它衡量的是一个散列表的空间的使用程度,负载因子越大表示散列表的装填程度越高,反之愈小。对于使用链表法的散列表来说,查找一个元素的平均时间是O(1+a),因此如果负载因子越大,对空间的利用更充分,然而后果是查找效率的降低;如果负载因子太小,那么散列表的数据将过于稀疏,对空间造成严重浪费。系统默认负载因子为0.75,一般情况下我们是无需修改的。
当哈希表中的条目数超出了加载因子与当前容量的乘积时,则要对该哈希表进行 rehash 操作(即重建内部数据结构),从而哈希表将具有大约两倍的桶数。
二、HashMap的数据结构
我们知道在Java中最常用的两种结构是数组和模拟指针(引用),几乎所有的数据结构都可以利用这两种来组合实现,HashMap也是如此。实际上HashMap是一个“链表散列”,如下是它数据结构:
从上图我们可以看出HashMap底层实现还是数组,只是数组的每一项都是一条链。其中参数initialCapacity就代表了该数组的长度。下面为HashMap构造函数的源码:
<span style="color:#000000"><code> <span style="color:#000088">public</span> <span style="color:#009900">HashMap</span>(<span style="color:#000088">int</span> initialCapacity, <span style="color:#000088">float</span> loadFactor) {
<span style="color:#880000">//容量不能小于0</span>
<span style="color:#000088">if</span> (initialCapacity < <span style="color:#006666">0</span>)
<span style="color:#000088">throw</span> <span style="color:#000088">new</span> IllegalArgumentException(<span style="color:#009900">"Illegal initial capacity: "</span> + initialCapacity);
<span style="color:#880000">//容量不能超出最大容量</span>
<span style="color:#000088">if</span> (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
<span style="color:#880000">//加载因子不能<=0 或者 为非数字</span>
<span style="color:#000088">if</span> (loadFactor <= <span style="color:#006666">0</span> || Float.isNaN(loadFactor))
<span style="color:#000088">throw</span> <span style="color:#000088">new</span> IllegalArgumentException(<span style="color:#009900">"Illegal load factor: "</span> +
loadFactor);
<span style="color:#880000">//计算出大于初始容量的最小 2的n次方作为哈希表table的长度,下面会说明为什么要这样</span>
<span style="color:#000088">int</span> capacity = <span style="color:#006666">1</span>;
<span style="color:#000088">while</span> (capacity < initialCapacity)
capacity <<= <span style="color:#006666">1</span>;
<span style="color:#000088">this</span>.loadFactor = loadFactor;
<span style="color:#880000">//设置HashMap的容量极限,当HashMap的容量达到该极限时就会进行扩容操作</span>
threshold = (<span style="color:#000088">int</span>)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + <span style="color:#006666">1</span>);
<span style="color:#880000">//创建Entry数组</span>
table = <span style="color:#000088">new</span> Entry[capacity];
useAltHashing = sun.misc.VM.isBooted() &&
(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
init();
}</code></span>
可以看到,这个构造函数主要做的事情就是:
1. 对传入的 容量 和 加载因子进行判断处理
2. 设置HashMap的容量极限
3. 计算出大于初始容量的最小 2的n次方作为哈希表table的长度,然后用该长度创建Entry数组(table),这个是最核心的
可以发现,一个HashMap对应一个Entry数组,来看看Entry这个元素的内部结构:
<span style="color:#000000"><code> <span style="color:#000088">static</span> <span style="color:#000088">class</span> <span style="color:#4f4f4f">Entry</span><<span style="color:#4f4f4f">K</span>,<span style="color:#4f4f4f">V</span>> <span style="color:#000088">implements</span> <span style="color:#4f4f4f">Map</span>.<span style="color:#4f4f4f">Entry</span><<span style="color:#4f4f4f">K</span>,<span style="color:#4f4f4f">V</span>> {
<span style="color:#000088">final</span> K key;
V value;
Entry<K,V> next;
<span style="color:#000088">int</span> hash;
<span style="color:#880000">/**
* Creates new entry.
*/</span>
Entry(<span style="color:#000088">int</span> h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}</code></span>
Entry是HashMap的一个内部类,它也是维护着一个key-value映射关系,除了key和value,还有next引用(该引用指向当前table位置的链表),hash值(用来确定每一个Entry链表在table中位置)
三、HashMap的存储实现put(K,V)
<span style="color:#000000"><code> <span style="color:#000088">public</span> V <span style="color:#009900">put</span>(K key, V <span style="color:#000088">value</span>) {
<span style="color:#880000">//如果key为空的情况</span>
<span style="color:#000088">if</span> (key == <span style="color:#000088">null</span>)
<span style="color:#000088">return</span> putForNullKey(<span style="color:#000088">value</span>);
<span style="color:#880000">//计算key的hash值</span>
<span style="color:#000088">int</span> hash = hash(key);
<span style="color:#880000">//计算该hash值在table中的下标</span>
<span style="color:#000088">int</span> i = indexFor(hash, table.length);
<span style="color:#880000">//对table[i]存放的链表进行遍历</span>
<span style="color:#000088">for</span> (Entry<K,V> e = table[i]; e != <span style="color:#000088">null</span>; e = e.next) {
Object k;
<span style="color:#880000">//判断该条链上是否有hash值相同的(key相同) </span>
<span style="color:#880000">//若存在相同,则直接覆盖value,返回旧value</span>
<span style="color:#000088">if</span> (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.<span style="color:#000088">value</span>;
e.<span style="color:#000088">value</span> = <span style="color:#000088">value</span>;
e.recordAccess(<span style="color:#000088">this</span>);
<span style="color:#000088">return</span> oldValue;
}
}
<span style="color:#880000">//修改次数+1</span>
modCount++;
<span style="color:#880000">//把当前key,value添加到table[i]的链表中</span>
addEntry(hash, key, <span style="color:#000088">value</span>, i);
<span style="color:#000088">return</span> <span style="color:#000088">null</span>;
}</code></span>
从上面的过程中,我们起码可以发现两点:
1. 如果为null,则调用putForNullKey:这就是为什么HashMap可以用null作为键的原因,来看看HashMap是如何处理null键的:
<span style="color:#000000"><code> <span style="color:#000088">private</span> V <span style="color:#009900">putForNullKey</span>(V <span style="color:#000088">value</span>) {
<span style="color:#880000">//查找链表中是否有null键</span>
<span style="color:#000088">for</span> (Entry<K,V> e = table[<span style="color:#006666">0</span>]; e != <span style="color:#000088">null</span>; e = e.next) {
<span style="color:#000088">if</span> (e.key == <span style="color:#000088">null</span>) {
V oldValue = e.<span style="color:#000088">value</span>;
e.<span style="color:#000088">value</span> = <span style="color:#000088">value</span>;
e.recordAccess(<span style="color:#000088">this</span>);
<span style="color:#000088">return</span> oldValue;
}
}
modCount++;
<span style="color:#880000">//如果链中查找不到,则把该null键插入</span>
addEntry(<span style="color:#006666">0</span>, <span style="color:#000088">null</span>, <span style="color:#000088">value</span>, <span style="color:#006666">0</span>);
<span style="color:#000088">return</span> <span style="color:#000088">null</span>;
}</code></span>
<span style="color:#000000"><code> <span style="color:#000088">void</span> addEntry(<span style="color:#000088">int</span> hash, K key, V <span style="color:#000088">value</span>, <span style="color:#000088">int</span> bucketIndex) {
<span style="color:#000088">if</span> ((size >= threshold) && (<span style="color:#000088">null</span> != table[bucketIndex])) {
resize(<span style="color:#006666">2</span> * table.length);
<span style="color:#880000">//这一步就是对null的处理,如果key为null,hash值为0,也就是会插入到哈希表的表头table[0]的位置</span>
hash = (<span style="color:#000088">null</span> != key) ? hash(key) : <span style="color:#006666">0</span>;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, <span style="color:#000088">value</span>, bucketIndex);
}</code></span>
2. 如果链中存在该key,则用传入的value覆盖掉旧的value,同时把旧的value返回:这就是为什么HashMap不能有两个相同的key的原因
对于hash操作,最重要也是最困难的就是如何通过确定hash的位置,我们来看看HashMap的做法:
首先求得key的hash值:hash(key)
<span style="color:#000000"><code> final int hash(<span style="color:#4f4f4f">Object</span> k) {
int h = <span style="color:#006666">0</span>;
<span style="color:#000088">if</span> (useAltHashing) {
<span style="color:#000088">if</span> (k <span style="color:#000088">instanceof</span> <span style="color:#4f4f4f">String</span>) {
<span style="color:#000088">return</span> sun.misc.Hashing.stringHash32((<span style="color:#4f4f4f">String</span>) k);
}
h = hashSeed;
}
h ^= k.hashCode();
h ^= (h >>> <span style="color:#006666">20</span>) ^ (h >>> <span style="color:#006666">12</span>);
<span style="color:#000088">return</span> h ^ (h >>> <span style="color:#006666">7</span>) ^ (h >>> <span style="color:#006666">4</span>);
}</code></span>
这是一个数学计算,可以不用深入,关键是下面这里:
计算该hash值在table中的下标
<span style="color:#000000"><code> static <span style="color:#000088">int</span> indexFor(<span style="color:#000088">int</span> h, <span style="color:#000088">int</span> <span style="color:#4f4f4f">length</span>) {
<span style="color:#000088">return</span> h & (<span style="color:#4f4f4f">length</span>-<span style="color:#006666">1</span>);
}</code></span>
对于HashMap的table而言,数据分布需要均匀(最好每项都只有一个元素,这样就可以直接找到),不能太紧也不能太松,太紧会导致查询速度慢,太松则浪费空间。计算hash值后,怎么才能保证table元素分布均与呢?我们会想到取模,但是由于取模的消耗较大,而HashMap是通过&运算符(按位与操作)来实现的:h & (length-1)
在构造函数中存在:capacity <<= 1,这样做总是能够保证HashMap的底层数组长度为2的n次方。当length为2的n次方时,h&(length - 1)就相当于对length取模,而且速度比直接取模快得多,这是HashMap在速度上的一个优化。至于为什么是2的n次方下面解释。
我们回到indexFor方法,该方法仅有一条语句:h&(length - 1),这句话除了上面的取模运算外还有一个非常重要的责任:均匀分布table数据和充分利用空间。
这里我们假设length为16(2^n)和15,h为5、6、7。
当length-1 = 14时,6和7的结果一样,这样表示他们在table存储的位置是相同的,也就是产生了碰撞,6、7就会在一个位置形成链表,这样就会导致查询速度降低详细地看看当length-1 = 14 时的情况:
可以看到,这样发生发生的碰撞是非常多的,1,3,5,7,9,11,13都没有存放数据,空间减少,进一步增加碰撞几率,这样就会导致查询速度慢,
分析一下:当length-1 = 14时,二进制的最后一位是0,在&操作时,一个为0,无论另一个为1还是0,最终&操作结果都是0,这就造成了结果的二进制的最后一位都是0,这就导致了所有数据都存储在2的倍数位上,所以说,所以说当length = 2^n时,不同的hash值发生碰撞的概率比较小,这样就会使得数据在table数组中分布较均匀,查询速度也较快。
然后我们来看看计算了hash值,并用该hash值来求得哈希表中的索引值之后,如何把该key-value插入到该索引的链表中:
调用 addEntry(hash, key, value, i) 方法:
<span style="color:#000000"><code> <span style="color:#000088">void</span> addEntry(<span style="color:#000088">int</span> hash, K key, V <span style="color:#000088">value</span>, <span style="color:#000088">int</span> bucketIndex) {
<span style="color:#880000">//如果size大于极限容量,将要进行重建内部数据结构操作,之后的容量是原来的两倍,并且重新设置hash值和hash值在table中的索引值</span>
<span style="color:#000088">if</span> ((size >= threshold) && (<span style="color:#000088">null</span> != table[bucketIndex])) {
resize(<span style="color:#006666">2</span> * table.length);
hash = (<span style="color:#000088">null</span> != key) ? hash(key) : <span style="color:#006666">0</span>;
bucketIndex = indexFor(hash, table.length);
}
<span style="color:#880000">//真正创建Entry节点的操作</span>
createEntry(hash, key, <span style="color:#000088">value</span>, bucketIndex);
}</code></span>
<span style="color:#000000"><code> <span style="color:#000088">void</span> createEntry(<span style="color:#000088">int</span> hash, K key, V <span style="color:#000088">value</span>, <span style="color:#000088">int</span> bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = <span style="color:#000088">new</span> Entry<>(hash, key, <span style="color:#000088">value</span>, e);
size++;
}</code></span>
首先取得bucketIndex位置的Entry头结点,并创建新节点,把该新节点插入到链表中的头部,该新节点的next指针指向原来的头结点
这里有两点需要注意:
一、链的产生
这是一个非常优雅的设计。系统总是将新的Entry对象添加到bucketIndex处。如果bucketIndex处已经有了对象,那么新添加的Entry对象将指向原有的Entry对象,形成一条Entry链,但是若bucketIndex处没有Entry对象,也就是e==null,那么新添加的Entry对象指向null,也就不会产生Entry链了。
二、扩容问题
还记得HashMap中的一个变量吗,threshold,这是容器的容量极限,还有一个变量size,这是指HashMap中键值对的数量,也就是node的数量
<span style="color:#000000"><code>threshold = (<span style="color:#000088">int</span>)Math.<span style="color:#4f4f4f">min</span>(capacity * loadFactor, MAXIMUM_CAPACITY + <span style="color:#006666">1</span>);</code></span>
什么时候发生扩容?
当不断添加key-value,size大于了容量极限threshold时,会发生扩容
如何扩容?
扩容发生在resize方法中,也就是扩大数组(桶)的数量,如何扩容参考:http://blog.csdn.net/jeffleo/article/details/63684953
我们重新来理一下存储的步骤:
1. 传入key和value,判断key是否为null,如果为null,则调用putForNullKey,以null作为key存储到哈希表中;
2. 然后计算key的hash值,根据hash值搜索在哈希表table中的索引位置,若当前索引位置不为null,则对该位置的Entry链表进行遍历,如果链中存在该key,则用传入的value覆盖掉旧的value,同时把旧的value返回,结束;
3. 否则调用addEntry,用key-value创建一个新的节点,并把该节点插入到该索引对应的链表的头部
四、HashMap的读取实现get(key,value)
<span style="color:#000000"><code> <span style="color:#000088">public</span> V <span style="color:#009900">get</span>(Object key) {
<span style="color:#880000">//如果key为null,求null键</span>
<span style="color:#000088">if</span> (key == <span style="color:#000088">null</span>)
<span style="color:#000088">return</span> getForNullKey();
<span style="color:#880000">// 用该key求得entry</span>
Entry<K,V> entry = getEntry(key);
<span style="color:#000088">return</span> <span style="color:#000088">null</span> == entry ? <span style="color:#000088">null</span> : entry.getValue();
}</code></span>
<span style="color:#000000"><code> final Entry<K,V> getEntry(<span style="color:#4f4f4f">Object</span> key) {
int hash = (key == <span style="color:#006666">null</span>) ? <span style="color:#006666">0</span> : hash(key);
<span style="color:#000088">for</span> (Entry<K,V> e = table[indexFor(hash, table.length)];
e != <span style="color:#006666">null</span>;
e = e.next) {
<span style="color:#4f4f4f">Object</span> k;
<span style="color:#000088">if</span> (e.hash == hash &&
((k = e.key) == key || (key != <span style="color:#006666">null</span> && key.equals(k))))
<span style="color:#000088">return</span> e;
}
<span style="color:#000088">return</span> <span style="color:#006666">null</span>;
}</code></span>
读取的步骤比较简单,调用hash(key)求得key的hash值,然后调用indexFor(hash)求得hash值对应的table的索引位置,然后遍历索引位置的链表,如果存在key,则把key对应的Entry返回,否则返回null
五、HashMap键的遍历,keySet()
HashMap遍历的核心代码如下:
<span style="color:#000000"><code> <span style="color:#000088">private</span> <span style="color:#000088">abstract</span> <span style="color:#000088">class</span> <span style="color:#4f4f4f">HashIterator</span><<span style="color:#4f4f4f">E</span>> <span style="color:#000088">implements</span> <span style="color:#4f4f4f">Iterator</span><<span style="color:#4f4f4f">E</span>> {
Entry<K,V> next; <span style="color:#880000">// next entry to return</span>
<span style="color:#000088">int</span> expectedModCount; <span style="color:#880000">// For fast-fail</span>
<span style="color:#000088">int</span> <span style="color:#000088">index</span>; <span style="color:#880000">// current slot</span>
Entry<K,V> current; <span style="color:#880000">// current entry</span>
<span style="color:#880000">//当调用keySet().iterator()时,调用此代码</span>
HashIterator() {
expectedModCount = modCount;
<span style="color:#000088">if</span> (size > <span style="color:#006666">0</span>) { <span style="color:#880000">// advance to first entry</span>
Entry[] t = table;
<span style="color:#880000">//从哈希表数组从上到下,查找第一个不为null的节点,并把next引用指向该节点</span>
<span style="color:#000088">while</span> (<span style="color:#000088">index</span> < t.length && (next = t[<span style="color:#000088">index</span>++]) == <span style="color:#000088">null</span>)
;
}
}
<span style="color:#000088">public</span> <span style="color:#000088">final</span> <span style="color:#000088">boolean</span> hasNext() {
<span style="color:#000088">return</span> next != <span style="color:#000088">null</span>;
}
<span style="color:#880000">//当调用next时,会调用此代码</span>
<span style="color:#000088">final</span> Entry<K,V> nextEntry() {
<span style="color:#000088">if</span> (modCount != expectedModCount)
<span style="color:#000088">throw</span> <span style="color:#000088">new</span> ConcurrentModificationException();
Entry<K,V> e = next;
<span style="color:#000088">if</span> (e == <span style="color:#000088">null</span>)
<span style="color:#000088">throw</span> <span style="color:#000088">new</span> NoSuchElementException();
<span style="color:#880000">//如果当前节点的下一个节点为null,从节点处罚往下查找哈希表,找到第一个不为null的节点</span>
<span style="color:#000088">if</span> ((next = e.next) == <span style="color:#000088">null</span>) {
Entry[] t = table;
<span style="color:#000088">while</span> (<span style="color:#000088">index</span> < t.length && (next = t[<span style="color:#000088">index</span>++]) == <span style="color:#000088">null</span>)
;
}
current = e;
<span style="color:#000088">return</span> e;
}
<span style="color:#000088">public</span> <span style="color:#000088">void</span> remove() {
<span style="color:#000088">if</span> (current == <span style="color:#000088">null</span>)
<span style="color:#000088">throw</span> <span style="color:#000088">new</span> IllegalStateException();
<span style="color:#000088">if</span> (modCount != expectedModCount)
<span style="color:#000088">throw</span> <span style="color:#000088">new</span> ConcurrentModificationException();
Object k = current.key;
current = <span style="color:#000088">null</span>;
HashMap.<span style="color:#000088">this</span>.removeEntryForKey(k);
expectedModCount = modCount;
}
}</code></span>
从这里可以看出,HashMap遍历时,按哈希表的每一个索引的链表从上往下遍历,由于HashMap的存储规则,最晚添加的节点都有可能在第一个索引的链表中,这就造成了HashMap的遍历时无序的。