深入理解JAVA集合系列一：HashMap源码解读

初认HashMap

基于哈希表（即散列表）的Map接口的实现，此实现提供所有可选的映射操作，并允许使用null值和null键。

HashMap继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。且是不同步的，意味着它不是线程安全的。

 HashMap的数据结构

在java编程语言中，最基本的结构就两种，一个是数组，另一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的。HashMap也不例外，它是一个“链表的数组”的数据结构。从下图中可以看出HashMap的底层就是一个table数组，数组的元素就是Entry。而Entry就是HashMap中的一个存储单元。

Entry的数据结构

table数组中的每个元素都是一个由Entry组成的单向链表，理解这句话对理解HashMap非常重要。

现在来看下单向链表上一个Entry的数据结构以及源码对其的定义

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;

 HashMap的底层实现

1、存储数据

首先从我编写的这段代码开始，开启HashMap的源码解析之路：

1 public static void main(String[] args)
2     {
3         Map<String,String> hashMap = new HashMap<String,String>();
4         hashMap.put("语文","89");
5         hashMap.put("数学","95");
6         hashMap.put("英语","88");
7     }

在第3行，创建了一个HashMap

1  public HashMap() {
2         this.loadFactor = DEFAULT_LOAD_FACTOR;
3         threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
4         table = new Entry[DEFAULT_INITIAL_CAPACITY];
5         init();
6     }

其中初始容量DEFAULT_INITIAL_CAPACITY为16，loadFactor（负载因子）为0.75。也就是说HashMap在创建的时候构造了一个大小为16的Entry数组。Entry内所有的数据都采用默认值null。

接下来看put方法底层实现是如何的：

 1 public V put(K key, V value) {
 2         if (key == null)
 3             return putForNullKey(value);
 4         int hash = hash(key.hashCode());
 5         int i = indexFor(hash, table.length);
 6         for (Entry<K,V> e = table[i]; e != null; e = e.next) {
 7             Object k;
 8             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
 9                 V oldValue = e.value;
10                 e.value = value;
11                 e.recordAccess(this);
12                 return oldValue;
13             }
14         }
15 
16         modCount++;
17         addEntry(hash, key, value, i);
18         return null;
19     }

1、在2、3两行上，可以看出HashMap允许key值为null的存在，并且存放在数组中下标为0的位置上。

2、在第4、5行上，对key的hashCode重新计算hash值，然后通过hash值作为下标，定位到table数组中的位置。在这里需要强调的是，不同的key最终得到的hash值可能会相同，这就是我们经常听说的“hash碰撞"。这也就意味着，table数组同一个位置上需要存放不同的Entry，这也就是会有单向链表的原因了。

3、下面我们来看下Entry单向链表是如何实现的：Entry类中有一个next属性，作用是指向下一个Entry。举个例子，第一个键值A进来，通过计算其key的hash值得到的index=4，记做Entry[0]=A。一会又来了一个键值B，计算得到的index也等于4，这时候怎么办？HashMap会这样做，B.next=A,Entry[0]=B。如果有进来C，index也等于4，那么情况就会变成这样，C.next=B,B.next=A,Entry[0]=C。最后我们会发现，在index=4的位置上，存储了ABC三个键值，它们通过next这个属性链接在一起。所以数组中存取的是最后插入的元素。

4.第6-14行，hash值定位到数组的某个元素上，然后对这个元素中的Entry单向链表做遍历，先对比hash值，在对比key值。如果相同，则覆盖并返回原有的value值，不执行后面的代码。

5、第16行的作用是用于fail-fast机制，每次修改hashMap数据结构的时候这个值都会自增。我们都知道HashMap是线程非安全的，如果在使用迭代器过程中有其他线程修改了map，将会抛出ConcurrentModificaitonException。这就是所谓的fail-fast的策略。

6、下面17行就是非常关键的addEntry：

1  void addEntry(int hash, K key, V value, int bucketIndex) {
2     Entry<K,V> e = table[bucketIndex];
3         table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
4         if (size++ >= threshold)
5             resize(2 * table.length);
6     }

第2行中e表示这个索引位置上现有的Entry，即在这之前最后插入的元素，如果这个位置上没有元素，则e为null。

第3行中，以本次新增的键值为属性创建了新的Entry，并且next指向e，这样就完成了put的动作。

第4、5两行就是在新增了元素之后，判断table数组是否需要扩容。一般是扩容现有容量的一倍。

2、删除数据

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

1、首先如果key为null，则返回的数组索引为0.

2、在4、5两行上，prev表示待删除的Entry前一个位置的Entry，e表示待删除的Entry。这个时候，可以看到prev=e，且是该该位置上第一个Entry。

3、7-23行上，如果第一次就满足了条件判断，则表示链表头上的Entry就是需要删除的Entry，且prev一定等于e，则table[i]就直接指向table[i]的下一个节点。

     如果第一次条件没有满足，说明链表头上的Entry不是这次需要删除的Entry。那么接下来就会有一个很优雅的设计：

1  prev = e;
2  e = next;

将e赋值给prev，而e表示下一个元素，然后再进行while循环做前面的一系列判断。当执行到17行的时候，e的前一个Entry（就是prev）的next直接执行e的后一个节点next，这样e就从这个单向链表中消失，e的前后Entry链接到一起了。

3、hashCode的作用

在HashMap提供的方法中，都会对key的hashCode做hash算法。那究竟这样有什么作用呢？

hash算法主要防止生成的index大量重复，就是前面提到的hash碰撞。如果index大量重复，就是导致同一个位置上的Entry会有多个，而有些位置上的entry没有。这样会严重影响性能：

如果10key，其中5个最终得到的index相同。这就意味着有一个位置上有5个Entry，另外5个均匀分布。所以在做存取或者删除的时候，就会反复执行这段代码：

1  if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

而在设计HashMap的时候，是希望元素能够随机均匀的分布在数组中，这样才能提升HashMap的效率。

转载于:https://www.cnblogs.com/dongguacai/p/5536396.html