深入讲解HashMap

先从构造函数讲起吧

HashMap有很多个构造函数，不过我们比较常用的是不带参数的默认构造函数，其源代码如下：

public HashMap() {        this.loadFactor = DEFAULT_LOAD_FACTOR;        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);        table = new Entry[DEFAULT_INITIAL_CAPACITY];        init();    }

事实上，HashMap的所有键值对被存放在一个Entry数组中（变量table），DEFAULT_INITIAL_CAPACITY（为16）即是默认的Entry数组长度的初始值，当然我们也可以自定义entry数组的长度，但是长度必须为2的n次方，为什么要如此，下面会讲解到。

Entry数组每一个索引处都可以存放一个Entry链（通过下面Entry的构造函数可以发现Entry对象可以指明它的下一个对象，所以多个Entry对象可以以Entry链的形式存在）

Entry类的构造函数如下：

 Entry(int h, K k, V v, Entry<K,V> n) {            value = v;            next = n;            key = k;            hash = h;        }

每个存入HashMap的键值对都会以Entry对象的形式储存，Entry类除了拥有key和value变量外，还有两个重要的变量：

next指明了下一个Entry对象
hash是该Entry对象的哈希值（Hash码）

HashMap在存入键值对时首先会根据key的hashCode() 返回值来计算 Hash 码，然后通过该Hash码计算出这个这个键值对要放在数组的哪个索引处，

如果该索引处还没有存放entry对象则用要存入的键值对新建一个Entry对象并将此对象存放于这个索引处，并将next变量赋为null；

如果该索引已经存在entry链，则遍历该entry链，如果entry链中含有key和要存入的key相等的entry对象，则将该对象的value值替换成我们要存入的value；

如果该索引已经存在entry链，且entry链中没有key和要存入的key相等的entry对象，则用要存入的键值对新建一个entry对象，然后将此对象存入改索引处，并将next指向该索引处之前的对象，也就是说将新的entry对象放入到entry链的链头中；

存入键值对的方法源代码如下：

 public V put(K key, V value)  {  // 如果 key 为 null，调用 putForNullKey 方法进行处理 if (key == null)  return putForNullKey(value);  // 根据 key 的 keyCode 计算 Hash 值 int hash = hash(key.hashCode());  // 搜索指定 hash 值在对应 table 中的索引  int i = indexFor(hash, table.length); // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素 for (Entry<K,V> e = table[i]; e != null; e = e.next)  {  Object k;  // 找到指定 key 与需要放入的 key 相等（hash 值相同 // 通过 equals 比较放回 true） if (e.hash == hash && ((k = e.key) == key  || key.equals(k)))  {  V oldValue = e.value;  e.value = value;  e.recordAccess(this);  return oldValue;  }  }  // 如果 i 索引处的 Entry 为 null，表明此处还没有 Entry  modCount++;  // 将 key、value 添加到 i 索引处 addEntry(hash, key, value, i);  return null;  } 

 

计算Hash码的方法hash是一个纯粹的数学计算，其方法如下：

static int hash(int h) {     h ^= (h >>> 20) ^ (h >>> 12);     return h ^ (h >>> 7) ^ (h >>> 4); } 

 对于任意给定的对象，只要它的 hashCode() 返回值相同，那么程序调用 hash(int h) 方法所计算得到的 Hash 码值总是相同的。

接下来程序会调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处。

indexFor(int h, int length) 方法的代码如下：

static int indexFor(int h, int length) {     return h & (length-1); }

这个方法非常巧妙，它总是通过 h &(table.length -1) 来得到该对象的保存位置——而 HashMap 底层数组的长度总是 2 的 n 次方

当 length 总是 2 的倍数时，h & (length-1) 将是一个非常巧妙的设计：

假设 h=5,length=16, 那么 h & length - 1 将得到 5；

如果 h=6,length=16, 那么 h & length - 1 将得到 6 ……如果 h=15,length=16, 那么 h & length - 1 将得到 15；

但是当 h=16 时 , length=16 时，那么 h & length - 1 将得到 0 了；

当 h=17 时 , length=16 时，那么 h & length - 1 将得到 1 了……

这样保证计算得到的索引值总是位于 table 数组的索引之内

其实看到这里也许你问，为什么不直接将hash码除以length然后取余数来获得索引值呢，这样不也是也可以实现索引值总是位于table数组的索引之内么？

原因我觉得应该是：与运算比除运算来的更有效率

 

当向 HashMap 中添加 key-value 对，由其 key 的 hashCode() 返回值决定该 key-value 对（就是 Entry 对象）的存储位置。

当两个 Entry 对象的 key 的 hashCode() 返回值相同时，将由 key 通过 eqauls() 比较值决定是采用覆盖行为（返回 true），还是产生 Entry 链（返回 false）。

上面程序中还调用了 addEntry(hash, key, value, i); 代码，其中 addEntry 是 HashMap 提供的一个包访问权限的方法，该方法仅用于添加一个 key-value 对。

下面是该方法的代码：

void addEntry(int hash, K key, V value, int bucketIndex) {     // 获取指定 bucketIndex 索引处的 Entry     Entry<K,V> e = table[bucketIndex];  // ①    // 将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry     table[bucketIndex] = new Entry<K,V>(hash, key, value, e);     // 如果 Map 中的 key-value 对的数量超过了极限    if (size++ >= threshold)         // 把 table 对象的长度扩充到 2 倍。        resize(2 * table.length);  // ②} 

size：该变量保存了该 HashMap 中所包含的 key-value 对的数量

threshold是阀值的意思，阀值等于Entry数组长度乘以负载因子，从上面的例子可以看出当size++ >= threshold 时，HashMap 会自动调用 resize 方法扩充 HashMap 的容量。每扩充一次，HashMap 的容量就增大一倍。

loadFactor即负载因子，默认的负载因子（DEFAULT_INITIAL_CAPACITY ）为0.75负载

增大负载因子可以减少 Hash 表（就是那个 Entry 数组）所占用的内存空间，但会增加查询数据的时间开销，而查询是最频繁的的操作（HashMap 的 get() 与 put() 方法都要用到查询）；

减小负载因子会提高数据查询的性能，但会增加 Hash 表所占用的内存空间

掌握了上面知识之后，我们可以在创建 HashMap 时根据实际需要适当地调整 load factor 的值；

如果程序比较关心空间开销、内存比较紧张，可以适当地增加负载因子；如果程序比较关心时间开销，内存比较宽裕则可以适当的减少负载因子。通常情况下，程序员无需改变负载因子的值。

如果开始就知道 HashMap 会保存多个 key-value 对，可以在创建时就使用较大的初始化容量，如果 HashMap 中 Entry 的数量一直不会超过极限容量（capacity * load factor），HashMap 就无需调用 resize() 方法重新分配 table 数组，从而保证较好的性能。当然，开始就将初始容量设置太高可能会浪费空间（系统需要创建一个长度为 capacity 的 Entry 数组），因此创建 HashMap 时初始化容量设置也需要小心对待。

 

接下来我们来看一下HashMap 的读取实现

当 HashMap 的每个 bucket 里存储的 Entry 只是单个 Entry ——也就是没有通过指针产生 Entry 链时，此时的 HashMap 具有最好的性能：当程序通过 key 取出对应 value 时，系统只要先计算出该 key 的 hashCode() 返回值，在根据该 hashCode 返回值找出该 key 在 table 数组中的索引，然后取出该索引处的 Entry，最后返回该 key 对应的 value 即可。

HashMap 类的 get(K key) 方法代码：

 public V get(Object key)  {  // 如果 key 是 null，调用 getForNullKey 取出对应的 value  if (key == null)  return getForNullKey();  // 根据该 key 的 hashCode 值计算它的 hash 码 int hash = hash(key.hashCode());  // 直接取出 table 数组中指定索引处的值， for (Entry<K,V> e = table[indexFor(hash, table.length)];  e != null;  // 搜索该 Entry 链的下一个 Entr  e = e.next)  // ① {  Object k;  // 如果该 Entry 的 key 与被搜索 key 相同 if (e.hash == hash && ((k = e.key) == key  || key.equals(k)))  return e.value;  }  return null;  } 

 

对于 HashMap 及其子类而言，它们采用 Hash 算法来决定集合中元素的存储位置。当系统开始初始化 HashMap 时，系统会创建一个长度为 capacity 的 Entry 数组，这个数组里可以存储元素的位置被称为“桶（bucket）”，每个 bucket 都有其指定索引，系统可以根据其索引快速访问该 bucket 里存储的元素。

无论何时，HashMap 的每个“桶”只存储一个元素（也就是一个 Entry），由于 Entry 对象可以包含一个引用变量（就是 Entry 构造器的的最后一个参数）用于指向下一个 Entry，因此可能出现的情况是：HashMap 的 bucket 中只有一个 Entry，但这个 Entry 指向另一个 Entry ——这就形成了一个 Entry 链。如图 1 所示：



图 1. HashMap 的存储示意