【JAVA】HashMap源码深度解析

1 举栗子

先来复习一下我们常用的几个方法

[java]  view plain  copy

1. public class HashMapTest {  
2.   
3.     public static void main(String[] args) {  
4.         // TODO Auto-generated method stub  
5.         HashMap<String, String> hashMap=new HashMap<>();  
6.         //添加方法  
7.         hashMap.put("1", "chris");  
8.                //遍历方法1_for  
9.         Set<String> keys=hashMap.keySet();  
10.         for(String key:keys){  
11.             System.out.println(key+"="+hashMap.get(key));  
12.         }  
13.         //遍历方法1_iterator(for和iterator实现原理相同)  
14.                 Iterator iter = map.keySet().iterator();   
15.                 while (iter.hasNext()) {   
16.                 String key = iter.next();   
17.                 String value = map.get(key);   
18.                 }   
19.         //遍历方法2_for  
20.                 Set<Entry<String, String>> entrys= hashMap.entrySet();  
21.         for(Entry<String, String> entry:entrys){  
22.             String key=entry.getKey();  
23.             String value=entry.getValue();  
24.         }  
25.         //遍历方法2_iterator  
26.         Iterator<Entry<String, String>> iterator=hashMap.entrySet().iterator();  
27.         while(iterator.hasNext()){  
28.             Map.Entry<String, String> entry=iterator.next();  
29.             String key=entry.getKey();  
30.             String value=entry.getValue();  
31.         }  
32.         //查询方法  
33.         hashMap.get("1");  
34.         //删除方法  
35.         hashMap.remove("1");          
36.     }  
37.   
38. }  

2 HashMap类图结构

3 HashMap数据结构

我们知道在Java中最常用的两种结构是数组和模拟指针(引用)，几乎所有的数据结构都可以利用这两种来组合实现。数组的存储方式在内存的地址是连续的，大小固定，一旦分配不能被其他引用占用。它的特点是查询快，时间复杂度是O(1)，插入和删除的操作比较慢，时间复杂度是O(n)，链表的存储方式是非连续的，大小不固定，特点与数组相反，插入和删除快，查询速度慢。HashMap可以说是一种折中的方案吧。

4 HashMap重要概念

5 HashMap源码分析

老规矩，按照使用的顺序来分析源码

1.HashMap<String, String> hashMap=new HashMap<>();

[java]  view plain  copy

1. public HashMap() {  
2.         this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);  
3.     }  

其中默认容量DEFAULT_INITIAL_CAPACITY

[java]  view plain  copy

1. static final int DEFAULT_INITIAL_CAPACITY = 4;//android N  

默认加载因子DEFAULT_LOAD_FACTOR

[java]  view plain  copy

1. static final float DEFAULT_LOAD_FACTOR = 0.75f;//android N  

构造函数有几个，但最后都会落到HashMap(int initialCapacity, float loadFactor)

[java]  view plain  copy

1. public HashMap(int initialCapacity, float loadFactor) {    
2.         //初始容量不能<0    
3.         if (initialCapacity < 0)    
4.             throw new IllegalArgumentException("Illegal initial capacity: "    
5.                     + initialCapacity);    
6.         //初始容量不能 > 最大容量值，HashMap的最大容量值为2^30    
7.         if (initialCapacity > MAXIMUM_CAPACITY)    
8.             initialCapacity = MAXIMUM_CAPACITY;    
9.         //负载因子不能 < 0    
10.         if (loadFactor <= 0 || Float.isNaN(loadFactor))    
11.             throw new IllegalArgumentException("Illegal load factor: "    
12.                     + loadFactor);    
13.     
14.         // 计算出大于 initialCapacity 的最小的 2 的 n 次方值。    
15.         int capacity = 1;    
16.         while (capacity < initialCapacity)    
17.             capacity <<= 1;    
18.             
19.         this.loadFactor = loadFactor;    
20.         //设置HashMap的容量极限，当HashMap的容量达到该极限时就会进行扩容操作    
21.         threshold = (int) (capacity * loadFactor);    
22.         //初始化table数组    
23.         table = new Entry[capacity];    
24.         init();    
25.     }  

其中涉及到位运算<<,，capacity <<= 1等价于capacity=capacity<<1，表示capacity左移1位
从源码中可以看出，每次新建一个HashMap时，都会初始化一个table数组。table数组的元素为Entry节点

[java]  view plain  copy

1. static class Entry<K,V> implements Map.Entry<K,V> {    
2.         final K key;    
3.         V value;    
4.         Entry<K,V> next;    
5.         final int hash;    
6.     
7.         /**  
8.          * Creates new entry.  
9.          */    
10.         Entry(int h, K k, V v, Entry<K,V> n) {    
11.             value = v;    
12.             next = n;    
13.             key = k;    
14.             hash = h;    
15.         }    
16.         .......    
17.     }  

其中Entry为HashMap的内部类，它包含了键key、值value、下一个节点next，以及hash值，这是非常重要的，正是由于Entry才构成了table数组的项为链表

2.hashMap.put("1", "chris");

先来看看put的几种分支

HashMap通过键的hashCode来快速的存取元素。当不同的对象hashCode发生碰撞时，HashMap通过单链表来解决，将新元素加入链表表头，通过next指向原有的元素。

先说说大概的过程：当我们调用put存值时，HashMap首先会获取key的哈希值，通过哈希值快速找到某个存放位置，这个位置可以被称之为bucketIndex。

对于一个key，如果hashCode不同，equals一定为false，如果hashCode相同，equals不一定为true。

所以理论上，hashCode可能存在冲突的情况，也叫发生了碰撞，当碰撞发生时，计算出的bucketIndex也是相同的，这时会取到bucketIndex位置已存储的元素，最终通过equals来比较，equals方法就是哈希码碰撞时才会执行的方法，所以说HashMap很少会用到equals。HashMap通过hashCode和equals最终判断出K是否已存在，如果已存在，则使用新V值替换旧V值，并返回旧V值，如果不存在 ，则存放新的键值对<K, V>到bucketIndex位置。

下面我们来看看put的源码

[java]  view plain  copy

1. public V put(K key, V value) {    
2.         //当key为null，调用putForNullKey方法，保存null于table第一个位置中，这是HashMap允许为null的原因    
3.         if (key == null)    
4.             return putForNullKey(value);    
5.         //计算key的hash值    
6.         int hash = hash(key.hashCode());                  ------(1)    
7.         //计算key hash 值在 table 数组中的位置    
8.         int i = <span style="font-family:Arial, Helvetica, sans-serif;">indexFor(hash, table.length)</span><span style="font-family:Arial, Helvetica, sans-serif;">;             ------(2)  </span>  
9.         //从i出开始迭代 e,找到 key 保存的位置    
10.         for (Entry<K, V> e = table[i]; e != null; e = e.next) {    
11.             Object k;    
12.             //判断该条链上是否有hash值相同的(key相同)    
13.             //若存在相同，则直接覆盖value，返回旧value    
14.             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {    
15.                 V oldValue = e.value;    //旧值 = 新值    
16.                 e.value = value;    
17.                 e.recordAccess(this);    
18.                 return oldValue;     //返回旧值    
19.             }    
20.         }    
21.         //修改次数增加1    
22.         modCount++;    
23.         //将key、value添加至i位置处    
24.         addEntry(hash, key, value, i);    
25.         return null;    
26.     }  

通过源码我们可以清晰看到HashMap保存数据的过程为：

1)首先判断key是否为null，若为null，则直接调用putForNullKey方法

[java]  view plain  copy

1. private V putForNullKey(V value) {  
2.         for (HashMapEntry<K,V> e = table[0]; e != null; e = e.next) {  
3.             if (e.key == null) {  
4.                 V oldValue = e.value;  
5.                 e.value = value;  
6.                 e.recordAccess(this);  
7.                 return oldValue;  
8.             }  
9.         }  
10.         modCount++;  
11.         addEntry(0, null, value, 0);  
12.         return null;  
13.     }  

从代码可以看出，如果key为null的值，默认就存储到table[0]开头的链表了。然后遍历table[0]的链表的每个节点Entry，如果发现其中存在节点Entry的key为null，就替换新的value，然后返回旧的value，如果没发现key等于null的节点Entry，就增加新的节点

2)计算key的hashcode（hash(key.hashCode())），再用计算的结果二次hash（indexFor(hash, table.length)），找到Entry数组的索引i，这里涉及到hash算法，最后会详细讲解

3)遍历以table[i]为头节点的链表，如果发现hash，key都相同的节点时，就替换为新的value，然后返回旧的value，只有hash相同时，循环内并没有做任何处理

4)modCount++代表修改次数，与迭代相关，在迭代篇会详细讲解

5)对于hash相同但key不相同的节点以及hash不相同的节点，就增加新的节点（addEntry()）

[java]  view plain  copy

1. void addEntry(int hash, K key, V value, int bucketIndex) {    
2.         //获取bucketIndex处的Entry    
3.         Entry<K, V> e = table[bucketIndex];    
4.         //将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry     
5.         table[bucketIndex] = new Entry<K, V>(hash, key, value, e);    
6.         //若HashMap中元素的个数超过极限了，则容量扩大两倍    
7.         if (size++ >= threshold)    
8.             resize(2 * table.length);    
9.     }   

这里新增加节点采用了头插法，新节点都增加到头部，新节点的next指向老节点

这里涉及到了HashMap的扩容问题，随着HashMap中元素的数量越来越多，发生碰撞的概率就越来越大，所产生的链表长度就会越来越长，这样势必会影响HashMap的速度，为了保证HashMap的效率，系统必须要在某个临界点进行扩容处理。该临界点在当HashMap中元素的数量等于table数组长度*加载因子。但是扩容是一个非常耗时的过程，因为它需要重新计算这些数据在新table数组中的位置并进行复制处理。

[java]  view plain  copy

1. void resize(int newCapacity) {  
2.         HashMapEntry[] oldTable = table;  
3.         int oldCapacity = oldTable.length;  
4.         if (oldCapacity == MAXIMUM_CAPACITY) {  
5.             threshold = Integer.MAX_VALUE;  
6.             return;  
7.         }  
8.   
9.         HashMapEntry[] newTable = new HashMapEntry[newCapacity];  
10.         transfer(newTable);  
11.         table = newTable;  
12.         threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);  
13.     }  

从代码可以看出，如果大小超过最大容量就返回。否则就new 一个新的Entry数组，长度为旧的Entry数组长度的两倍。然后将旧的Entry[]复制到新的Entry[].

[java]  view plain  copy

1. void transfer(HashMapEntry[] newTable) {  
2.         int newCapacity = newTable.length;  
3.         for (HashMapEntry<K,V> e : table) {  
4.             while(null != e) {  
5.                 HashMapEntry<K,V> next = e.next;  
6.                 int i = indexFor(e.hash, newCapacity);  
7.                 e.next = newTable[i];  
8.                 newTable[i] = e;  
9.                 e = next;  
10.             }  
11.         }  
12.     }  

在复制的时候数组的索引int i = indexFor(e.hash, newCapacity);重新参与计算

3.Iterator iter = map.keySet().iterator();

keySet()方法可以获取包含key的set集合，调用该集合的迭代器可以对key值遍历

[java]  view plain  copy

1. public Set<K> keySet() {  
2.         Set<K> ks = keySet;  
3.         if (ks == null) {  
4.             ks = new KeySet();  
5.             keySet = ks;  
6.         }  
7.         return ks;  
8.     }  

KeySet是HashMap中的内部类，继承AbstractSet，KeySet中获取的迭代器为KeyIterator

[java]  view plain  copy

1. private final class KeySet extends AbstractSet<K> {  
2.         public Iterator<K> iterator() {  
3.             return new KeyIterator();  
4.         }  
5.         ......  
6.     }  

KeyIterator继承自HashIterator

[java]  view plain  copy

1. private final class KeyIterator extends HashIterator<K> {  
2.         public K next() {  
3.             return nextEntry().getKey();  
4.         }  
5.     }  

[java]  view plain  copy

1. private abstract class HashIterator<E> implements Iterator<E> {  
2.         HashMapEntry<K,V> next;        // next entry to return  
3.         int expectedModCount;   // For fast-fail  
4.         int index;              // current slot  
5.         HashMapEntry<K,V> current;     // current entry  
6.   
7.         HashIterator() {  
8.             expectedModCount = modCount;  
9.             if (size > 0) { // advance to first entry  
10.                 HashMapEntry[] t = table;  
11.                 while (index < t.length && (next = t[index++]) == null)  
12.                     ;  
13.             }  
14.         }  
15.   
16.         public final boolean hasNext() {  
17.             return next != null;  
18.         }  
19.   
20.         final Entry<K,V> nextEntry() {  
21.             if (modCount != expectedModCount)  
22.                 throw new ConcurrentModificationException();  
23.             HashMapEntry<K,V> e = next;  
24.             if (e == null)  
25.                 throw new NoSuchElementException();  
26.   
27.             if ((next = e.next) == null) {  
28.                 HashMapEntry[] t = table;  
29.                 while (index < t.length && (next = t[index++]) == null)  
30.                     ;  
31.             }  
32.             current = e;  
33.             return e;  
34.         }  
35.   
36.         public void remove() {  
37.             if (current == null)  
38.                 throw new IllegalStateException();  
39.             if (modCount != expectedModCount)  
40.                 throw new ConcurrentModificationException();  
41.             Object k = current.key;  
42.             current = null;  
43.             HashMap.this.removeEntryForKey(k);  
44.             expectedModCount = modCount;  
45.         }  
46.     }  

4.Iterator<Entry<String, String>> iterator=hashMap.entrySet().iterator();

[java]  view plain  copy

1. public Set<Map.Entry<K,V>> entrySet() {  
2.         return entrySet0();  
3.     }  

[java]  view plain  copy

1. private Set<Map.Entry<K,V>> entrySet0() {  
2.         Set<Map.Entry<K,V>> es = entrySet;  
3.         return es != null ? es : (entrySet = new EntrySet());  
4.     }  

EntrySet是HashMap内部类，继承AbstractSet，EntrySet中获取的迭代器为EntryIterator

[java]  view plain  copy

1. private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {  
2.         public Iterator<Map.Entry<K,V>> iterator() {  
3.             return newEntryIterator();  
4.         }        ......  
5.     }  

[java]  view plain  copy

1. Iterator<Map.Entry<K,V>> newEntryIterator()   {  
2.         return new EntryIterator();  
3.     }  

[java]  view plain  copy

1. private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {  
2.         public Map.Entry<K,V> next() {  
3.             return nextEntry();  
4.         }  
5.     }  

[java]  view plain  copy

1. private abstract class HashIterator<E> implements Iterator<E> {  
2.         HashMapEntry<K,V> next;        // next entry to return  
3.         int expectedModCount;   // For fast-fail  
4.         int index;              // current slot  
5.         HashMapEntry<K,V> current;     // current entry  
6.   
7.         HashIterator() {  
8.             expectedModCount = modCount;  
9.             if (size > 0) { // advance to first entry  
10.                 HashMapEntry[] t = table;  
11.                 while (index < t.length && (next = t[index++]) == null)  
12.                     ;  
13.             }  
14.         }  
15.   
16.         public final boolean hasNext() {  
17.             return next != null;  
18.         }  
19.   
20.         final Entry<K,V> nextEntry() {  
21.             if (modCount != expectedModCount)  
22.                 throw new ConcurrentModificationException();  
23.             HashMapEntry<K,V> e = next;  
24.             if (e == null)  
25.                 throw new NoSuchElementException();  
26.   
27.             if ((next = e.next) == null) {  
28.                 HashMapEntry[] t = table;  
29.                 while (index < t.length && (next = t[index++]) == null)  
30.                     ;  
31.             }  
32.             current = e;  
33.             return e;  
34.         }  
35.   
36.         public void remove() {  
37.             if (current == null)  
38.                 throw new IllegalStateException();  
39.             if (modCount != expectedModCount)  
40.                 throw new ConcurrentModificationException();  
41.             Object k = current.key;  
42.             current = null;  
43.             HashMap.this.removeEntryForKey(k);  
44.             expectedModCount = modCount;  
45.         }  
46.     }  

显然entrySet()遍历的效率会比keySet()高，因为keySet获取key的集合后，还需要调用get（）方法，相当于遍历两次

5.hashMap.get("1");

[java]  view plain  copy

1. public V get(Object key) {    
2.         // 若为null，调用getForNullKey方法返回相对应的value    
3.         if (key == null)    
4.             return getForNullKey();    
5.         // 根据该 key 的 hashCode 值计算它的 hash 码      
6.         int hash = hash(key.hashCode());    
7.         // 取出 table 数组中指定索引处的值    
8.         for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {    
9.             Object k;    
10.             //若搜索的key与查找的key相同，则返回相对应的value    
11.             if (e.hash == hash && ((k = e.key) == key || key.equals(k)))    
12.                 return e.value;    
13.         }    
14.         return null;    
15.     }  

在这里能够根据key快速的取到value除了和HashMap的数据结构密不可分外，还和Entry有莫大的关系，在前面就提到过，HashMap在存储过程中并没有将key，value分开来存储，而是当做一个整体key-value来处理的，这个整体就是Entry对象。同时value也只相当于key的附属而已。在存储的过程中，系统根据key的hashcode来决定Entry在table数组中的存储位置，在取的过程中同样根据key的hashcode取出相对应的Entry对象

6.hashMap.remove("1");

[java]  view plain  copy

1. public V remove(Object key) {  
2.         Entry<K,V> e = removeEntryForKey(key);  
3.         return (e == null ? null : e.getValue());  
4.     }  

[java]  view plain  copy

1. final Entry<K,V> removeEntryForKey(Object key) {  
2.         if (size == 0) {  
3.             return null;  
4.         }  
5.         int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);  
6.         int i = indexFor(hash, table.length);  
7.         HashMapEntry<K,V> prev = table[i];  
8.         HashMapEntry<K,V> e = prev;  
9.   
10.         while (e != null) {  
11.             HashMapEntry<K,V> next = e.next;  
12.             Object k;  
13.             if (e.hash == hash &&  
14.                 ((k = e.key) == key || (key != null && key.equals(k)))) {  
15.                 modCount++;  
16.                 size--;  
17.                 if (prev == e)  
18.                     table[i] = next;  
19.                 else  
20.                     prev.next = next;  
21.                 e.recordRemoval(this);  
22.                 return e;  
23.             }  
24.             prev = e;  
25.             e = next;  
26.         }  
27.   
28.         return e;  
29.     }  

6 总结

1.HashMap结合了数组和链表的优点，使用Hash算法加快访问速度，使用散列表解决碰撞冲突的问题，其中数组的每个元素是单链表的头结点，链表是用来解决冲突的

2.HashMap有两个重要的参数：初始容量和加载因子。这两个参数极大的影响了HashMap的性能。初始容量是hash数组的长度，当前加载因子=当前hash数组元素/hash数组长度，最大加载因子为最大能容纳的数组元素个数（默认最大加载因子为0.75），当hash数组中的元素个数超出了最大加载因子和容量的乘积时，要对hashMap进行扩容，扩容过程存在于hashmap的put方法中，扩容过程始终以2次方增长。

3.HashMap是泛型类，key和value可以为任何类型，包括null类型。key为null的键值对永远都放在以table[0]为头结点的链表中，当然不一定是存放在头结点table[0]中。

4.哈希表的容量一定是2的整数次幂，我们在HashMap算法篇会详细讲解