深刻讲解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 的存储示意