HashMap详谈以及实现原理

（一）.HashMap

基于哈希表的 Map 接口的实现
允许使用 null 值和 null 键
HashMap不是线程安全，想要线程安全，Collections类的静态方法synchronizedMap获得线程安全的HashMap

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

底层基于数组和链表实现
相当快的查询速度主要是因为它是通过计算散列码来决定存储的位置
HashMap中主要是通过key的hashCode来计算hash值的，只要hashCode相同，计算出来的hash值就一样。如果存储的对象对多了，就有可能不同的对象所算出来的hash值是相同的，这就出现了所谓的hash冲突。解决hash冲突的方法有很多，HashMap底层是通过链表来解决hash冲突的
紫色部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的头节点，链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中
HashMap 中Entry（1.8以下）的代码

 1 /**    Entry是单向链表。    
 2      * 它是 “HashMap链式存储法”对应的链表。    
 3      * 它实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o),  hashCode()这些函数  
 4  **/  
 5     static class Entry<K,V> implements Map.Entry<K,V> {    
 6         final K key;    
 7         V value;    
 8         // 指向下一个节点    
 9         Entry<K,V> next;    
10         final int hash;    
11    
12         // 构造函数。    
13         // 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"    
14         Entry(int h, K k, V v, Entry<K,V> n) {    
15             value = v;    
16             next = n;    
17             key = k;    
18             hash = h;    
19         }    
20    
21         public final K getKey() {    
22             return key;    
23         }    
24    
25         public final V getValue() {    
26             return value;    
27         }    
28    
29         public final V setValue(V newValue) {    
30             V oldValue = value;    
31             value = newValue;    
32             return oldValue;    
33         }    
34    
35         // 判断两个Entry是否相等    
36         // 若两个Entry的“key”和“value”都相等，则返回true。    
37         // 否则，返回false    
38         public final boolean equals(Object o) {    
39             if (!(o instanceof Map.Entry))    
40                 return false;    
41             Map.Entry e = (Map.Entry)o;    
42             Object k1 = getKey();    
43             Object k2 = e.getKey();    
44             if (k1 == k2 || (k1 != null && k1.equals(k2))) {    
45                 Object v1 = getValue();    
46                 Object v2 = e.getValue();    
47                 if (v1 == v2 || (v1 != null && v1.equals(v2)))    
48                     return true;    
49             }    
50             return false;    
51         }    
52    
53         // 实现hashCode()    
54         public final int hashCode() {    
55             return (key==null   ? 0 : key.hashCode()) ^    
56                    (value==null ? 0 : value.hashCode());    
57         }    
58    
59         public final String toString() {    
60             return getKey() + "=" + getValue();    
61         }    
62    
63         // 当向HashMap中添加元素时，绘调用recordAccess()。    
64         // 这里不做任何处理    
65         void recordAccess(HashMap<K,V> m) {    
66         }    
67   
68         // 当从HashMap中删除元素时，绘调用recordRemoval()。    
69         // 这里不做任何处理    
70         void recordRemoval(HashMap<K,V> m) {    
71         }    
72     }

HashMap 中Entry（jdk1.8）的代碼

/**
     * Basic hash bin node, used for most entries.  (See below for
     * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
     */
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

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

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

HashMap其实就是一个Entry（Node）数组，Entry（Node）对象中包含了键和值，其中next也是一个Entry（Node）对象，它就是用来处理hash冲突的，形成一个链表
HashMap源码分析
一些重要属性

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

loadFactor加载因子是表示Hsah表中元素的填满的程度.若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但:冲突的机会加大了.链表长度会越来越长,查找效率降低反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了.表中的数据将过于稀疏（很多空间还没用，就开始扩容了）冲突的机会越大,则查找的成本越高.因此,必须在 "冲突的机会"与"空间利用率"之间寻找一种平衡与折衷. 这种平衡与折衷本质上是数据结构中有名的"时-空"矛盾的平衡与折衷.如果机器内存足够，并且想要提高查询速度的话可以将加载因子设置小一点；相反如果机器内存紧张，并且对查询速度没有什么要求的话可以将加载因子设置大一点。不过一般我们都不用去设置它，让它取默认值0.75就好了。
常用的构造方法

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);
        // Find a power of 2 >= initialCapacity
        int capacity = 1;   //初始容量
        while (capacity < initialCapacity)   //确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂
            capacity <<= 1;
        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        table = new Entry[capacity];
       init();
   }

    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
   }

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

默认初始容量为16，默认加载因子为0.75。我们可以看到上面代码中13-15行，这段代码的作用是确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂，至于为什么要把容量设置为2的n次幂，我们等下再看。

put方法
- ```
 1 public V put(K key, V value) {
 2      // 若“key为null”，则将该键值对添加到table[0]中。
 3          if (key == null) 
 4             return putForNullKey(value);
 5      // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。
 6          int hash = hash(key.hashCode());
 7      //搜索指定hash值在对应table中的索引
 8          int i = indexFor(hash, table.length);
 9      // 循环遍历Entry数组,若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
10          for (Entry<K,V> e = table[i]; e != null; e = e.next) { 
11               Object k;
12               if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  //如果key相同则覆盖并返回旧值
13                  V oldValue = e.value;
14                  e.value = value;
15                  e.recordAccess(this);
16                  return oldValue;
17               }
18          }
19      //修改次数+1
20          modCount++;
21      //将key-value添加到table[i]处
22      addEntry(hash, key, value, i);
23      return null;
24 }    
```
```
 1 /**上面程序中用到了一个重要的内部接口：Map.Entry，每个 Map.Entry 其实就是一个 key-value 对。从上面程序中可以看出：当系统决定存储 HashMap 中的 key-value 对时，完全没有考虑 Entry 中的 value，仅仅只是根据 key 来计算并决定每个 Entry 的存储位置。这也说明了前面的结论：我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。我们慢慢的来分析这个函数，第2和3行的作用就是处理key值为null的情况，我们看看
 2 */
 3 private V putForNullKey(V value) {
 4         for (Entry<K,V> e = table[0]; e != null; e = e.next) {
 5             if (e.key == null) {   //如果有key为null的对象存在，则覆盖掉
 6                 V oldValue = e.value;
 7                 e.value = value;
 8                 e.recordAccess(this);
 9                 return oldValue;
10            }
11        }
12         modCount++;
13         addEntry(0, null, value, 0); //如果键为null的话，则hash值为0
14         return null;
15     }
16 
17 /**
18 
19 如果key为null的话，hash值为0，对象存储在数组中索引为0的位置。即table[0]我们再回去看看put方法中第4行，它是通过key的hashCode值计算hash码，下面是计算hash码的函数：
20 */
21 //计算hash值的方法 通过键的hashCode来计算
22     static int hash(int h) {
23         // This function ensures that hashCodes that differ only by
24         // constant multiples at each bit position have a bounded
25         // number of collisions (approximately 8 at default load factor).
26         h ^= (h >>> 20) ^ (h >>> 12);
27         return h ^ (h >>> 7) ^ (h >>> 4);
28     }
29 /**
30 得到hash码之后就会通过hash码去计算出应该存储在数组中的索引，计算索引的函数如下：
31 */
32   static int indexFor(int h, int length) { //根据hash值和数组长度算出索引值
33      return h & (length-1);  //这里不能随便算取，用hash&(length-1)是有原因的，这样可以确保算出来的索引是在数组大小范围内，不会超出
34   }
```
  　　这个我们要重点说下，我们一般对哈希表的散列很自然地会想到用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值发生碰撞的概率较小，这样就能使元素在哈希表中均匀地散列。

　　　　　　　　参考：Java集合---HashMap源码剖析

posted @ 2017-05-10 00:49 meiyouor 阅读(298) 评论(0) 编辑收藏举报

刷新页面返回顶部

Blankjor_'Blog

不要在最需要奋斗的年龄里选择了安逸！

HashMap详谈以及实现原理

（一）.HashMap

公告