JDK源码学习之HashMap

一、概述

HashMap是我们工作中经常使用的类，方便我们存储数据，然后通过Key来进行快速查找。

二、实现

类头：

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

继承自AbstractMap,实现了Map,克隆，序列化接口

———————————————————————————————————————————————————    

          属性： 

    static final int DEFAULT_INITIAL_CAPACITY = 16;//默认初始容量大小16

    static final int MAXIMUM_CAPACITY = 1 << 30;//能容纳最多个数

    static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认的载入因子，扩容依据，具体方法会看到作用

    transient Entry[] table;//存储数据数组，原来HashMap内部实现也是通过数组来实现的，但是它是如何通过Key来实现快速查找，而且保证删除很快的?这里也被声明了为禁止序列化，应该跟ArrayList原理一样

    transient int size;//大小 

    int threshold;//临界值，=容量*载入因子用来判断合适进行扩容

    final float loadFactor;//载入因子

    transient volatile int modCount;//修改计数器，作用跟ArrayList一样

____________________________________________________________________________________________ 

         方法： 

       

构造器：一共四个，指定大小跟载入因子、只制定大小、默认构造器和通过Map集合来创建

public HashMap() {//默认构造器
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

void init() {//钩子方法，子类可以重写该方法，添加自己的特殊实现来保证父类的方法可以同样适用于子类。
    }

        

static int hash(int h) {//自己的hash算法，这里是为了防止Key的hash算法不好，导致hash冲突过多，降低查找效率,采用了“防御性编程”的解决方法，进行二次hash
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

 static int indexFor(int h, int length) {//通过传入的hash跟table长度来找到对应元素所在位置，这是Map实现快速查找的基础
        return h & (length-1);
    }

  下面来重点学习一下HashMap的查找方法：

 public V get(Object key) {
        if (key == null)//查找key为null的value
            return getForNullKey();
        int hash = hash(key.hashCode());//通过计算一步定位到key所在行数
        for (Entry<K,V> e = table[indexFor(hash, table.length)];//因为存在Hash冲突，所以要遍历同一行数据来找到到真正的值
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

 private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

获取key为null的value，通过table[0]来获得，说明null被存储在table[0]里面,也说明了HashMap可以添加null key

 static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;..............}

这里我们还需要看一下Entry这个类，这个类内部有key，

value（终于找到我们熟悉的key跟value了）,还有next引用，它指向同一行数相邻数据。

结构如下图

该图摘自alex09大侠希望不要介意。

这样我们就明白HashMap是如何提高查找效率的了，通过Hash算法，把每个元素放到表中的不同位置，查找到时候直接计算得出结果，这样，效率的高低取决于元素是否分布的足够均匀，如果没有hash冲突，通过计算一次就能查找到对应value，所以设计者自己添加了一个hash计算方法来提高效率。这是很有必要的。加快Hash效率的另一个有效途径是编写良好的自定义对象的HashCode，String的实现采用了如下的计算方法：

 for (int i = 0; i < len; i++) {
        h = 31*h + val[off++];
  }

这种方法HashCode的计算方法可能最早出现在Brian W. Kernighan和Dennis M. Ritchie的《The C Programming Language》中，被认为是性价比最高的算法，实际上，包括List在内的大多数的对象都是用这种方法计算Hash值。

  
  

   
   public boolean containsKey(Object key) {//查找是否包含key
  
  
  
  

   
           return getEntry(key) != null;
  
  
  
  

   
   }
  
  

 final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

该方法可以查找到key为null的value,实现近似get()方法

存储方法：存储是查找的实现基础，通过分析查找我们应该能反推出HashMap是如何实现的存储。下面来具体看一下实现：

 public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        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))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

void addEntry(int hash, K key, V value, int bucketIndex) {
	Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    }

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

 void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

    上面是存储过程中主要使用的几个方法，果然跟我们想的一样，HashMap会存储key为null的值(好像有点罗嗦)，并且只会存储一个key为null的，key非null的会通过计算直接得出该key应该被存放的位置，这里总是将新添加的 Entry 对象放入 table 数组的 bucketIndex 索引处,如果 bucketIndex 索引处已经有了一个 Entry 对象，那新添加的 Entry 对象指向原有的 Entry 对象（产生一个 Entry 链），如果 bucketIndex 索引处没有 Entry 对象，也就是上面程序代码的 e 变量是 null，也就是新放入的 Entry 对象指向 null，也就是没有产生 Entry 链。

    如果空间不够，依据是size>=临界值，会进行扩容（resize），然后重新根据新生成的数据进行hash分布，这个耗时很严重，所以性能要求高的项目里面，尽量避免使用默认HashMap，另外HashMap在添加时没有同步，如果多线程存放，transfer方法可能会导致闭环，形成死循环，导致CPU过高，所以在多线程情况下使用记得同步，切记。

 public boolean containsValue(Object value) {
	if (value == null)
            return containsNullValue();

	Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++)
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (value.equals(e.value))
                    return true;
	return false;
    }

    判断value是否存在，查找的时候通过全部遍历，效率低，查找到时候优先通过key

    

再看一下删除方法：

 public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

    通过key查找然后删除，会返回原来的value值

public void clear() {
        modCount++;
        Entry[] tab = table;
        for (int i = 0; i < tab.length; i++)
            tab[i] = null;
        size = 0;
    }

    清除方法，跟ArrayList基本一样，问题：为什么不直接table = new table[16];

三、总结

  

HashMap是线程不安全的类，多线程情况下，要使用同步锁，否则容易因为闭环而产生死循环，使得CPU 100%。可以存放key为null的值，查找删除很快（查找肯定没有ArrayList快），默认创建大小为16，每次达到临界值会进行扩容，扩大到原来的2倍，这个过程中会重新进行hash排列，耗时严重，尽量少使用containsValue方法，效率低。

    学习hash的“防御性编程”，理解临界值的使用技巧，学习通过modCount实现Fail-Fast机制,学习常用的hashCode方法（31），理解如何通过数组一维结构来实现key跟value的两两对应关系，说白了就是key作为一个纽带来联系两者。领会HashMap是如何实现快速查找的，利用hash算法。