java学习之集合---浅析HashMap

浅析HashMap的实现

 

预备知识：

查找：根据输入的值在指定的数组中查找其是否存在。

基本的查找可以为：

在有序的数组中：折半查找

在无序数组中：顺序查找（改进的顺序查找：如果待查数组有规律，在查到某个位置后不再进行查找，从而减少查找次数）

Hash法：将待查数据经过hash函数计算后，得到存储位置，存放在指定位置。在查找时只需要计算就可得到是否存在某个元素（这里不讨论冲突的发生，及处理冲突的方法）。

Hash函数：根据指定值计算相应的hash值。

Hash函数的基本常见函数：数字分析法（根据数字本身的特性进行位置的确定）、除留余数法（将输入的值和不大于待散列数组的最大质数进行取余确定位置）、平方取中法（将数字去平方后，选择平方后的数字的中间部分）等

Hash产生冲突的原因：经过hash函数后的值有相同的。这是不可避免的，只能尽量减少。

冲突处理方法：

①    开放定址：线性探测再散列、随机探测等。优点：易于实现。缺点：增加了冲突的可能性，导致随后的冲突率增加；在查找过程中增加了查找次数。

②    拉链法：为每个冲突的元素创建一个结点，数据部分存放元素，指针部分指向下一个冲突元素的结点。优点：不会影响随后的元素插入。缺点：增加了内存开销。注意：JAVA中的HashMap和Oracle数据库中对于有相同hashcode值的数据存放采用的就是这个方式。

填充率：元素个数和数组长度的比值称为填充率。它是衡量一个hash函数好坏的标志之一，另外可以在达到某些值后进行长度的扩充，减少冲突。

HashMap：利用键值对存放数据。形式<Key k,Value v>。这里键值要求唯一，如果在插入过程中插入有相同的Key的键值对，会导致原来键值对中的值域部分被改变，从而引起数据的不一致。

下面解读HashMap的部分源码。

类之间的关系就不在一一赘述。差API知道，HashMap继承AbstractMap,实现了Map接口,Map接口定义了所有Map子类必须实现的方法。HashMap继承的父类和实现的接口和Set及List不同，它没有实现Collection接口。

　　

HashMap的实例有两个参数影响其性能：初始容量和加载因子。初始容量只是哈希表在创建时的容量。加载因子是哈希表再其容量自动增加之前可以达到多满的一种尺度。当哈希表中的元素个数超出了加载因子与当前容量的乘积时，则要对该哈希表进行rehash操作（扩容操作）。

　　HashMap中定义的属性：

 2      //默认的初始容量16.

 4     static final int DEFAULT_INITIAL_CAPACITY = 16;

 6     //最大容量，也就是2的30次幂（假设这里采用补码存储数字）

8      static final intMAXIMUM_CAPACITY = 1 << 30;

10     //默认装填因子0.75（公式为：元素个数和table长度的比值）.

12     static final float DEFAULT_LOAD_FACTOR = 0.75f;

 

14     //存储数据的Entry数组

16     transient Entry[] table;

 

18     // map中保存的键值对的数量，也就是元素的个数

20     transient int size;

21     

22      // 需要调整大小的极限值（容量*装载因子）

24      int threshold;

25     

26      //装载因子,当HashMap的数据大小>=容量*加载因子时，HashMap会将容量扩容

28     final float loadFactor;

29     

30      // map结构被改变的次数，基本没怎么使用

32     transient volatile int modCount;

 

HashMap的构造方法。

 

//使用默认的容量及装载因子构造一个空的HashMap

4     public HashMap() {

 5        this.loadFactor = DEFAULT_LOAD_FACTOR;

 6        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);

 7        table = new Entry[DEFAULT_INITIAL_CAPACITY];//根据默认容量初始化table

 8        init();

 9     }

11     //根据给定的初始容量的装载因子创建一个空的HashMap

12     //初始容量小于0或装载因子小于等于0将报异常

14    public HashMap(int initialCapacity, float loadFactor) {

15        if (initialCapacity < 0)

16             throw new IllegalArgumentException("Illegalinitial capacity: " +

17                                               initialCapacity);

18        if (initialCapacity > MAXIMUM_CAPACITY)

19             initialCapacity =MAXIMUM_CAPACITY;

20        if (loadFactor <= 0 || Float.isNaN(loadFactor))

21             throw newIllegalArgumentException("Illegal load factor: " +

22                                               loadFactor);

23        int capacity = 1;

24        //设置capacity为大于initialCapacity且是2的幂的最小值

25        while (capacity < initialCapacity)

26             capacity <<= 1;

27        this.loadFactor = loadFactor;

28        threshold = (int)(capacity * loadFactor);

29        table = new Entry[capacity];

30        init();

31    }

32 　　

33    //根据指定容量创建一个空的HashMap，这里装填因子为默认值0.75f

35    public HashMap(int initialCapacity) {

36        this(initialCapacity, DEFAULT_LOAD_FACTOR);

38 　//通过传入的map创建一个HashMap，容量为默认容量（16）和(map.zise()/DEFAULT_LOAD_FACTORY)+1的较大者。

41    public HashMap(Map<? extends K, ? extends V> m) {

42        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,

43                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);

44        putAllForCreate(m);

45    }

 

　　注意：在第二个构造方法中，capacity才是初始容量，而不是initialCapacity，即如果执行new HashMap(9,0.75),那么HashMap的初始容量是16，而不是9。根据装填因子的公式可知：数组长度为：元素个数除以装填因子。

　　在初始化table的时候都使用了Entry,这是HashMap的一个内部类。Map.Entry接口定义的方法：K getKey();V getValue();VsetValue();boolean equals(Object o);int hashCode();

　　HashMap.Entry类的具体实现

 1static 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;//每个key的hash值唯一，不能被改变

 7         Entry(int h, K k, V v, Entry<K,V> n) {

 8             value = v;

 9             next = n;

10              key = k;

11              hash = h;

12         }

13 

14         public final K getKey() {

15              return key;

16         }

17 

18         public final V getValue() {

19              return value;

20         }

21 

22         public final V setValue(V newValue) {

23         　　V oldValue =value;

24              value = newValue;

25              return oldValue;//返回的是之前的Value

26         }

27 

28         public final boolean equals(Object o) {

29              if (!(o instanceof Map.Entry))//先判断类型是否一致

30                 return false;

31              Map.Entry e = (Map.Entry)o;

32              Object k1 = getKey();

33              Object k2 = e.getKey();

34  　　// Key相等且Value相等则两个Entry相等，如果hash值也等，则冲突。

35              if (k1 == k2 || (k1 != null&& k1.equals(k2))) {

36                  Object v1 = getValue();

37                  Object v2 = e.getValue();

38                  if (v1 == v2 || (v1 != null&& v1.equals(v2)))

39                      return true;

40              }

41              return false;

42          }

43         // hashCode是Key的hashCode和Value的hashCode的异或的结果

44         public final int hashCode() {

45              return (key==null   ? 0 : key.hashCode()) ^

46                     (value==null ? 0 :value.hashCode());

47         }

48         // 重写toString方法，是输出更清晰

49         public final String toString() {

50              return getKey() + "=" +getValue();

51         }

52 

56         void recordAccess(HashMap<K,V> m) {

57         }

58 

62         void recordRemoval(HashMap<K,V> m) {

63         }

64      }

 

　put()方法剖析：

 1public V put(K key, V value) {

 2         if (key == null)

 3             return putForNullKey(value);

 4         int hash = hash(key.hashCode());//得到key的hash值，这个值不是索引位置

 5         int i = indexFor(hash, table.length);//根据hash值和table的长度得到在table的位置

 6         for (Entry<K,V> e = table[i]; e != null; e = e.next) {

//这里得到在table的i位置上的e,如果e不为空，则说明该位置上有元素，那么判断输入

//的键值对的hash码及其equals方法是否相等，如果相等，说明输入的元素的key值和已存在的相等，那么将它的value覆盖原来的value。

 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     }

　　当待put的key为null的时候会调用putForNullKey(value)方法,暂且绕过，先来看看如何hash。HashMap并 不是直接将对象的hashcode作为哈希值，而是把key的hashcode做一些运算以得到最终的哈希值，而且得到的哈希值也不是在数组中的位置，无 论是get还是put还是别的方法，计算哈希值都是：

1 int hash = hash(key.hashCode());

1 static int hash(int h) {

2         // This function ensures that hashCodes that differ only by

3         // constant multiples at each bit position have a bounded

4         // number of collisions (approximately 8 at default load factor).

5         h ^= (h >>> 20) ^ (h >>> 12);

6         return h ^ (h >>> 7) ^ (h >>> 4);

7     }

　　hash方法为什么要这样取值，有待探讨，但是作用肯定是防止冲突。如何确定数据在数组中的位置：

1 int hash = hash(k.hashCode());

2 int i = indexFor(hash,table.length);

　　第一行，得到哈希值，第二行，根据哈希值计算元素在数组中的位置。

1 static int indexFor(int h,int length){

2       return h & (length - 1); 

3 }

　　"h&(length-1)"是一个进行与的运算。

　　首先我们要确定，HashMap的数组长度永远是偶数，所以length-1一定是一个奇数，假设现在的长度是16，length-1就是15，对应的二进制是：1111。

　　假设有两个元素，一个哈希值是8，二进制是1000，一个哈希值是9，二进制是1001。和1111与运算后，分别还是1000和1001，他们被分配在了数组的不同位置，这样，哈希的分布非常均匀。

　　那么如果数组的长度是奇数，减去1后就是偶数了，偶数对应的二进制最低位一定是0，例如14二进制1110。对上面两个数字分别与运算，得到 1000和1000。这样，哈希值8和9的元素会被存储在数组同一个位置的链表中。在操作的时候，链表中的元素越多，效率就会越低，因为要不停的对链表循环比较。

　　在找到元素在数组中的索引位置以后，会循环遍历table[i]所在的链表，如果找到key值与传入的key值相同的对象，则替换并返回原对象；若找不到，则通过addEntry(hash,key,value,i)添加新的对象。

1 void addEntry(int hash, K key, V value,int bucketIndex) {    
　　　　Entry<K,V>e = table[bucketIndex];

2     table[bucketIndex] = new Entry<K,V>(hash, key, value, e);

3     if (size++ >= threshold)

4     　　resize(2 *table.length);

5    }

　　以上过程就是新建一个Entry对象，并放在当前位置的Entry链表的头部。然后判断size是否达到了需要扩容的界限并让size增加1，如果达到了扩容的界限则调用resize(int capacity)方法。

 1void resize(int newCapacity) {

 2         Entry[] oldTable = table;

 3         int oldCapacity = oldTable.length;

 4         // 这个if块表明，如果容量已经到达允许的最大值，即MAXIMUN_CAPACITY，则不再拓展容量，而将装载拓展的界限值设为计算机允许的最大值。

 5         // 不会再触发resize方法，而是不断的向map中添加内容，即table数组中的链表可以不断变长，但数组长度不再改变

 6         if (oldCapacity == MAXIMUM_CAPACITY) {

 7             threshold = Integer.MAX_VALUE;

 8             return;

 9         }

10          // 创建新数组，容量为指定的容量

11         Entry[] newTable = new Entry[newCapacity];

12         transfer(newTable);

13         table = newTable;

14         // 设置下一次需要调整数组大小的界限

15         threshold = (int)(newCapacity * loadFactor);

16     }

　　这里需要重点看看transfer方法：

 1void transfer(Entry[] newTable) {

 2         // 保留原数组的引用到src中，

 3         Entry[] src = table;

 4         // 新容量使新数组的长度

 5         int newCapacity = newTable.length;

 6  　　　　　// 遍历原数组

 7         for (int j = 0; j < src.length; j++) {

 8             // 获取元素e

 9             Entry<K,V> e = src[j];

10              if (e != null) {

11                  // 将原数组中的元素置为null

12                  src[j] = null;

13                  // 遍历原数组中j位置指向的链表

14                  do {

15                      Entry<K,V> next = e.next;

16                      // 根据新的容量计算e在新数组中的位置

17                      int i = indexFor(e.hash,newCapacity);

18                      // 将e插入到newTable[i]指向的链表的头部

19                      e.next = newTable[i];

20                      newTable[i] = e;

21                      e = next;

22                  } while (e != null);

23              }

24         }

25     }

　　tranfer方法将所有的元素重新哈希，因为新的容量变大，所以每个元素的哈希值和位置都是不一样的。

　　如果key值为空，我们来看看putForNullKey的处理过程：

 1private V putForNullKey(V value) {

 2         for (Entry<K,V> e = table[0]; e != null; e = e.next) {

 3             if (e.key == null) {

 4                  V oldValue = e.value;

 5                  e.value = value;

 6                  e.recordAccess(this);

 7                  return oldValue;

 8             }

 9         }

10         modCount++;

11         addEntry(0, null, value, 0);

12         return null;

13     }

　　这是一个私有方法，在put方法中被调用。它首先遍历table数组，如果找到key为null的元素，则替换值并返回oldValue；否则通过addEntry方法添加元素，并返回null。

　　正确的使用HashMap

　　1.不要再并发场景中使用HashMap

　　　HashMap是线程不安全的，如果被多个线程共享的操作，将会引发不可预知的问题。据sun的说法，在扩容时，会引起链表的闭环，在get元素时，就会无限循环。

 1public V get(Object key) {

 2     if(key == null)

 3        return getForNullKey();

 4        int hash = hash(key.hashCode());

 5        for (Entry<K,V> e = table[indexFor(hash, table.length)];

 6              e != null;

 7             e = e.next) {

 8             Object k;

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

10                 return e.value;

11        }

12        return null;

13    }