Java集合（7）：HashMap

一.HashMap介绍

　　HashMap是基于哈希表的 Map 接口的实现，以key-value的形式存在。在HashMap中，key-value总是会当做一个整体来处理，系统会根据hash算法来来计算key-value的存储位置，我们总是可以通过key快速地存、取value。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。HashMap不保证映射的顺序，特别是它不保证该顺序恒久不变。

　　HashMap不是线程安全的，如果想要线程安全的HashMap，可以通过Collections类的静态方法synchronizedMap获得线程安全的HashMap。

Map map = Collections.synchronizedMap(new HashMap());

　　除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。

1.HashMap的继承关系

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

2.HashMap的类图关系

　　HashMap实现了Map接口，继承AbstractMap。其中Map接口定义了键映射到值的规则，而AbstractMap类提供 Map 接口的骨干实现，以最大限度地减少实现此接口所需的工作（其实AbstractMap类已经实现了Map）。

二.HashMap源码解析

1.数据结构

　　在Java中最常用的两种结构是数组和模拟指针(引用)，几乎所有的数据结构都可以利用这两种来组合实现，HashMap也是如此。实际上HashMap是一个“链表散列”，它的底层实现还是数组，只是数组的每一项都是一条链。如下是它数据结构：

　　最左侧的部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的头节点，链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中。

HashMap中Entry类的代码如下：

 /** Entry是单向链表。
 * 它是 “HashMap链式存储法”对应的链表。
 *它实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数
 **/
 static class Entry<K,V> implements Map.Entry<K,V> {
     final K key;
     V value;
     // 指向下一个节点
     Entry<K,V> next;
     final int hash;    

     // 构造函数。
     // 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"
     Entry(int h, K k, V v, Entry<K,V> n) {
         value = v;
         next = n;
         key = k;
         hash = h;
     }    

     public final K getKey() {
         return key;
     }    

     public final V getValue() {
         return value;
     }    

     public final V setValue(V newValue) {
         V oldValue = value;
         value = newValue;
         return oldValue;
     }    

     // 判断两个Entry是否相等
     // 若两个Entry的“key”和“value”都相等，则返回true。
     // 否则，返回false
     public final boolean equals(Object o) {
         if (!(o instanceof Map.Entry))
             return false;
         Map.Entry e = (Map.Entry)o;
         Object k1 = getKey();
         Object k2 = e.getKey();
         if (k1 == k2 || (k1 != null && k1.equals(k2))) {
             Object v1 = getValue();
             Object v2 = e.getValue();
             if (v1 == v2 || (v1 != null && v1.equals(v2)))
                 return true;
         }
         return false;
     }    

     // 实现hashCode()
     public final int hashCode() {
         return (key==null   ? 0 : key.hashCode()) ^
                (value==null ? 0 : value.hashCode());
     }    

     public final String toString() {
         return getKey() + "=" + getValue();
     }    

     // 当向HashMap中添加元素时，绘调用recordAccess()。
     // 这里不做任何处理
     void recordAccess(HashMap<K,V> m) {
     }    

     // 当从HashMap中删除元素时，绘调用recordRemoval()。
     // 这里不做任何处理
     void recordRemoval(HashMap<K,V> m) {
     }
 }

　　HashMap其实就是一个Entry数组，Entry对象中包含了键和值，其中next也是一个Entry对象，它就是用来处理hash冲突的，形成一个链表。

2.HashMap关键属性

 transient Entry[] table;//存储元素的实体数组
 transient int size;//存放元素的个数
 int threshold; //临界值。当实际大小超过临界值时，会进行扩容threshold = 加载因子*容量
 final float loadFactor; //加载因子
 transient int modCount;//被修改的次数

其中loadFactor加载因子是表示Hsah表中元素的填满的程度.

若加载因子越大，填满的元素越多，好处是空间利用率高了，但冲突的机会加大了。链表长度会越来越长，查找效率降低。

反之,加载因子越小，填满的元素越少，好处是冲突的机会减小了，但空间浪费多了。表中的数据将过于稀疏（很多空间还没用，就开始扩容了）

冲突的机会越大,则查找的成本越高。必须在 "冲突的机会"与"空间利用率"之间寻找一种平衡与折衷. 如果机器内存足够，并且想要提高查询速度的话可以将加载因子设置小一点；相反如果机器内存紧张，并且对查询速度没有什么要求的话可以将加载因子设置大一点。不过一般我们都不用去设置它，让它取默认值0.75就好了。

3.HashMap的构造方法

 /**
  *使用默认的容量及装载因子构造一个空的HashMap
  */
 public HashMap() {
     this.loadFactor = DEFAULT_LOAD_FACTOR;
     threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);//计算下次需要调整大小的极限值
     table = new Entry[DEFAULT_INITIAL_CAPACITY];//根据默认容量（16）初始化table
     init();
 }
 /**
  * 根据给定的初始容量的装载因子创建一个空的HashMap
  * 初始容量小于0或装载因子小于等于0将报异常
  */
 public HashMap(int initialCapacity, float loadFactor) {
     if (initialCapacity < 0)
         throw new IllegalArgumentException("Illegal initial capacity: " +
                                            initialCapacity);
     if (initialCapacity > MAXIMUM_CAPACITY)//调整最大容量
         initialCapacity = MAXIMUM_CAPACITY;
     if (loadFactor <= 0 || Float.isNaN(loadFactor))
         throw new IllegalArgumentException("Illegal load factor: " +
                                            loadFactor);
     int capacity = 1;//初始容量
     //设置capacity为大于initialCapacity且是2的幂的最小值
     while (capacity < initialCapacity)
         capacity <<= 1;
     this.loadFactor = loadFactor;
     threshold = (int)(capacity * loadFactor);
     table = new Entry[capacity];
     init();
 }
 /**
  *根据指定容量创建一个空的HashMap
  */
 public HashMap(int initialCapacity) {
     this(initialCapacity, DEFAULT_LOAD_FACTOR);//调用上面的构造方法，容量为指定的容量，装载因子是默认值
 }
 /**
  *通过传入的map创建一个HashMap，容量为默认容量（16）和(map.zise()/DEFAULT_LOAD_FACTORY)+1的较大者，装载因子为默认值
  */
 public HashMap(Map<? extends K, ? extends V> m) {
     this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                   DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
     putAllForCreate(m);
 }

　　在构造HashMap的时候如果我们指定了加载因子和初始容量的话就调用第一个构造方法，否则的话就是用默认的。默认初始容量为16，默认加载因子为0.75。我们可以看到上面代码中13-15行，这段代码的作用是确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂。

4.存储数据put

 public V put(K key, V value) {
      // 若“key为null”，则将该键值对添加到table[0]中。
          if (key == null)
             return putForNullKey(value);
      // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。
          int hash = hash(key.hashCode());
      //搜索指定hash值在对应table中的索引
          int i = indexFor(hash, table.length);
      // 循环遍历Entry数组,若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
          for (Entry<K,V> e = table[i]; e != null; e = e.next) {
               Object k;
               if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { //如果key相同则覆盖并返回旧值
                  V oldValue = e.value;
                  e.value = value;
                  e.recordAccess(this);
                  return oldValue;
               }
          }
      //修改次数+1
      modCount++;
      //将key-value添加到table[i]处
      addEntry(hash, key, value, i);
      return null;
 }

　　Map 集合中的 value 是 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。

　　下面具体解析put函数里面用到的其他的函数。

4.1 putForNullKey()

第3和4行的作用就是处理key值为null时用到的putForNullKey(value)方法如下：

 private V putForNullKey(V value) {
     for (Entry<K,V> e = table[0]; e != null; e = e.next) {
         if (e.key == null) {   //如果有key为null的对象存在，则覆盖掉
             V oldValue = e.value;
             e.value = value;
             e.recordAccess(this);
             return oldValue;
        }
    }
     modCount++;
     addEntry(0, null, value, 0); //如果键为null的话，则hash值为0
     return null;
 }

注意：如果key为null的话，hash值为0，对象存储在数组中索引为0的位置，即table[0]。

4.2 hash()

put方法中第6行通过key的hashCode值计算hash的的函数hash(int h)如下：

 //计算hash值的方法 通过键的hashCode来计算
 static int hash(int h) {
     h ^= (h >>> 20) ^ (h >>> 12);
     return h ^ (h >>> 7) ^ (h >>> 4);
 }

4.3 indexFor()

put方法中第8行通过hash码去计算数组中存储的索引值的函数indexFor(int h, int length)如下：

 static int indexFor(int h, int length) { //根据hash值和数组长度算出索引值
     return h & (length-1);  //这里不能随便算取，用hash&(length-1)是有原因的，这样可以确保算出来的索引是在数组大小范围内，不会超出
 }

　　一般对哈希表的散列进行取模是用hash值对length取模（即除法散列法），Hashtable中也是这样实现的，这种方法基本能保证元素在哈希表中散列的比较均匀，但取模会用到除法运算，效率很低。HashMap中则通过h&(length-1)的方法来代替取模，同样实现了均匀的散列，但效率要高很多，这也是HashMap对Hashtable的一个改进。

下面我们分析下为什么哈希表的容量一定要是2的整数次幂。

　　首先，length为2的整数次幂的话，h&(length-1)就相当于对length取模，这样便保证了散列的均匀，同时也提升了效率；其次，length为2的整数次幂的话，为偶数，这样length-1为奇数，奇数的最后一位是1，这样便保证了h&(length-1)的最后一位可能为0，也可能为1（这取决于h的值），即与后的结果可能为偶数，也可能为奇数，这样便可以保证散列的均匀性，而如果length为奇数的话，很明显length-1为偶数，它的最后一位是0，这样h&(length-1)的最后一位肯定为0，即只能为偶数，这样任何hash值都只会被散列到数组的偶数下标位置上，这便浪费了近一半的空间，因此，length取2的整数次幂，是为了使不同hash值发生碰撞的概率较小，这样就能使元素在哈希表中均匀地散列。

下面通过流程图来梳理一下整个put过程：

下面是两个例子。

例1：假设length为16(2^n)和15，h为5、6、7。如下图：

当n=15时，6和7的结果一样，这样表示他们在table存储的位置是相同的，也就是产生了碰撞，6、7就会在一个位置形成链表，这样就会导致查询速度降低。

例2：假设length为15，h为0-15。如下图：

　　上图中共发生了8此碰撞，同时发现浪费的空间非常大，有1、3、5、7、9、11、13、15处没有记录，也就是没有存放数据。这是因为他们在与14进行&运算时，得到的结果最后一位永远都是0，即0001、0011、0101、0111、1001、1011、1101、1111位置处是不可能存储数据的，空间减少，进一步增加碰撞几率，这样就会导致查询速度慢。而当length = 16时，length – 1 = 15 即1111，那么进行低位&运算时，值总是与原来hash值相同，而进行高位运算时，其值等于其低位值。所以说当length = 2^n时，不同的hash值发生碰撞的概率比较小，这样就会使得数据在table数组中分布较均匀，查询速度也较快。

4.4 addEntry()

　　当我们向一个HashMap中添加一对key-value时，系统首先会计算key的hash值，然后根据hash值确认在table中存储的位置。若该位置没有元素，则直接插入。否则迭代该处元素链表并依此比较其key的hash值。如果两个hash值相等且key值相等(e.hash == hash && ((k = e.key) == key || key.equals(k)))，则用新的Entry的value覆盖原来节点的value。如果两个hash值相等但key值不等 ，则将该节点插入该链表的链头。具体的实现过程见addEntry方法如下：

 void addEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex]; //如果要加入的位置有值，将该位置原先的值设置为新entry的next,也就是新entry链表的下一个节点
    table[bucketIndex] = new Entry<>(hash, key, value, e);//将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry
    if (size++ >= threshold) //如果大于临界值就扩容
        resize(2 * table.length); //以2的倍数扩容
 }

注意：

1.链的产生。

　　这是一个非常优雅的设计。系统总是将新的Entry对象添加到bucketIndex处。如果bucketIndex处已经有了对象，那么新添加的Entry对象将指向原有的Entry对象，形成一条Entry链，但是若bucketIndex处没有Entry对象，也就是e==null,那么新添加的Entry对象指向null，也就不会产生Entry链了。

2.扩容问题。

　　随着HashMap中元素的数量越来越多，发生碰撞的概率就越来越大，所产生的链表长度就会越来越长，这样势必会影响HashMap的速度，为了保证HashMap的效率，系统必须要在某个临界点进行扩容处理。该临界点在当HashMap中元素的数量等于table数组长度*加载因子。但是扩容是一个非常耗时的过程，因为它需要重新计算这些数据在新table数组中的位置并进行复制处理。所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

5.数据读取get()

　　HashMap读取数据相对简单一些，通过key的hash值找到在table数组中的索引处的Entry，然后返回该key对应的value即可。

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

在存储的过程中，系统根据key的hashcode来决定Entry在table数组中的存储位置，在取的过程中同样根据key的hashcode取出相对应的Entry对象。

6.其他方法

6.1 containsKey、getEntry

public boolean containsKey(Object key)

final Entry<K,V> getEntry(Object key)

containsKey调用了getEntry方法，根据getEntry的结果是否为null进行返回，是则返回false，否返回true。

6.2 remove

public V remove(Object key)

6.3 clear()

public void clear()

6.4 使用到迭代器Iterator的方法

entrySet()、keySet()、values()

三. LinkedHashMap

public class LinkedHashMap<K, V> extends HashMap<K, V> implements Map<K, V>  

　　LinkedHashMap是HashMap的一个子类，它保留插入的顺序，如果需要输出的顺序和输入时的相同，那么就选用LinkedHashMap。LinkedHashMap实现与HashMap的不同之处在于，前者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。

　　实现：它继承与HashMap、底层使用哈希表与双向链表来保存所有元素。其基本操作与父类HashMap相似，它通过重写父类相关的方法，来实现自己的链接列表特性。

　　根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序(调用get方法)的链表。

　　默认是按插入顺序排序，如果指定按访问顺序排序，那么调用get方法后，会将这次访问的元素移至链表尾部，不断访问可以形成按访问顺序排序的链表。 可以重写removeEldestEntry方法返回true值指定插入元素时移除最老的元素。

参考：http://cmsblogs.com/?p=176

http://www.cnblogs.com/ITtangtang/p/3948406.html

http://blog.csdn.net/ghsau/article/details/16843543/

http://www.cnblogs.com/hzmark/archive/2012/12/24/HashMap.html

http://www.cnblogs.com/children/archive/2012/10/02/2710624.html