Java集合源码学习（四）HashMap分析

原文地址：https://yq.aliyun.com/articles/38410?spm=5176.8091938.0.0.01LA3v

摘要

ArrayList、LinkedList和HashMap的源码是一起看的，横向对比吧，感觉对这三种数据结构的理解加深了很多。 数据结构中有数组和链表来实现对数据的存储，这两者有不同的应用场景， 数组的特点是：寻址容易，插入和删除困难；链表的特点是：寻址困难，插入和删除容易； 哈希表的实现结合了这两点，哈希表的实现方式有多种，在HashMap中使用的是链地址法，也就是拉链法。

---

数组、链表和哈希表结构

数据结构中有数组和链表来实现对数据的存储，这两者有不同的应用场景，
数组的特点是：寻址容易，插入和删除困难；链表的特点是：寻址困难，插入和删除容易；
哈希表的实现结合了这两点，哈希表的实现方式有多种，在HashMap中使用的是链地址法，也就是拉链法。
看下面这张流传很广的图，

拉链法实际上是一种链表数组的结构，由数组加链表组成，在这个长度为16的数组中（HashMap默认初始化大小就是16），每个元素存储的是一个链表的头结点。
通过元素的key的hash值对数组长度取模，将这个元素插入到数组对应位置的链表中。
例如在图中，337%16=1，353%16=1，于是将其插入到数组位置1的链表头结点中。

关于HashMap

继承和实现

继承AbstractMap抽象类，Map的一些操作在AbstractMap里已经提供了默认实现，
实现Map接口，可以应用Map接口定义的一些操作，明确HashMap属于Map体系，
Cloneable接口，表明HashMap对象会重写java.lang.Object#clone()方法，HashMap实现的是浅拷贝（shallow copy），
Serializable接口，表明HashMap对象可以被序列化

内部数据结构

HashMap的实际数据存储在Entry类的数组中，
上面说到HashMap的基础就是一个线性数组，这个数组就是Entry[]。

/**     * 内部实际的存储数组，如果需要调整，容量必须是2的幂     */    transient Entry[] table;

再来看一下Entry这个内部静态类，

static class Entry<K,V> implements Map.Entry<K,V> {        final K key;//Key-value结构的key        V value;//存储值        Entry<K,V> next;//指向下一个链表节点        final int hash;//哈希值        /**         * Creates new entry.         */        Entry(int h, K k, V v, Entry<K,V> n) {            value = v;            next = n;            key = k;            hash = h;        }        ......  }

线程安全

HashMap是非同步的，即线程不安全，在多线程条件下，可能出现很多问题，1. 多线程put后可能导致get死循环，具体表现为CPU使用率100%（put的时候transfer方法循环将旧数组中的链表移动到新数组）2. 多线程put的时候可能导致元素丢失（在addEntry方法的new Entry<K,V>(hash, key, value, e)，如果两个线程都同时取得了e,则他们下一个元素都是e，然后赋值给table元素的时候有一个成功有一个丢失）

需要线程安全的哈希表结构，可以考虑以下的方式：

• 使用Hashtable 类，Hashtable 是线程安全的；
• 使用并发包下的java.util.concurrent.ConcurrentHashMap，ConcurrentHashMap实现了更高级的线程安全；
• 或者使用synchronizedMap() 同步方法包装 HashMap object，得到线程安全的Map，并在此Map上进行操作.。
  如：

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {        return new SynchronizedMap<>(m);    }

常用方法

Map接口定义的方法

HashMap可以应用所有Map接口定义的方法：

public interface Map<K,V> {    public static interface Entry<K,V> {        //获取该Entry的key        public abstract Object getKey();        //获取该Entry的value        public abstract Object getValue();        //设置Entry的value         public abstract Object setValue(Object obj);        public abstract boolean equals(Object obj);        public abstract int hashCode();    }    //返回键值对的数目     int size();    //判断容器是否为空     boolean isEmpty();    //判断容器是否包含关键字key     boolean containsKey(Object key);    //判断容器是否包含值value    boolean containsValue(Object value);     //根据key获取value     Object get(Object key);     //向容器中加入新的key-value对     Object put(Object key, Object value);    //根据key移除相应的键值对     Object remove(Object key);    //将另一个Map中的所有键值对都添加进去     void putAll(Map<? extends K, ? extends V> m);    //清除容器中的所有键值对     void clear();    //返回容器中所有的key组成的Set集合     Set keySet();    //返回所有的value组成的集合     Collection values();     //返回所有的键值对     Set<Map.Entry<K, V>> entrySet();    //继承自Object的方法    boolean equals(Object obj);    int hashCode();}

构造方法　

HashMap使用Entry[] 数组存储数据，
另外维护了两个非常重要的变量：initialCapacity（初始容量）、loadFactor（加载因子）。

初始容量就是初始构造数组的大小，可以指定任何值，

但最后HashMap内部都会将其转成一个大于指定值的最小的2的幂，比如指定初始容量12，但最后会变成16，指定16，最后就是16。
加载因子是控制数组table的饱和度的，默认的加载因子是0.75，

DEFAULT_LOAD_FACTOR = 0.75f;

也就是数组达到容量的75%，就会自动的扩容。
扩容每次*2

另外，HashMap的最大容量是2^30，
static final int MAXIMUM_CAPACITY = 1 << 30;
默认的初始化大小是16，
static final int DEFAULT_INITIAL_CAPACITY = 16;

HashMap提供了四种构造方法，可以使用默认的容量等进行初始化，
也可以显式制定大小和加载因子，还可以使用另外的map进行构造和初始化。

public HashMap() {    this.loadFactor = DEFAULT_LOAD_FACTOR;    threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);    table = new Entry[DEFAULT_INITIAL_CAPACITY];     init();    }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);    } public HashMap(int initialCapacity) {        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }  public HashMap(int initialCapacity, float loadFactor) {      ......  }

解决哈希冲突的办法

什么是哈希冲突

理论上哈希函数的输入域是无限的，优秀的哈希函数可以将冲突减少到最低，但是却不能避免，下面是一个典型的哈希冲突的例子：

解决哈希冲突的方法

常见的办法开放定址法，再哈希法，链地址法以及建立一个公共溢出区等，这里只考察链地址法。
链地址法就是最开始我们提到的链表-数组结构，

将所有关键字为同义词的记录存储在同一线性链表中。

源码分析

HashMap的存取实现

HashMap的存取主要是put和get操作的实现。

执行put方法时根据key的hash值来计算放到table数组的下标，
如果hash到相同的下标，则覆盖这个value,否则将新的对象put进去的元素放到Entry链的头部。

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

get操作的实现：

public V get(Object key) {        if (key == null)            return getForNullKey();        int hash = hash(key.hashCode());        for (Entry<K,V> e = table[indexFor(hash, table.length)];e != null;e = e.next) <br>        {   Object k;            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))                return e.value;        }        return null;    }

注意HashMap支持key=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;            }        }        ......    }

哈希函数

下面看一下HashMap使用的哈希函数，源码来自JDK1.6：

/**     * 哈希函数     * 看一下具体的操作，首先对h分别进行无符号右移20位和12位，     * 然后对两个值进行按位异或，最后再与h进行按位异或，     * 得到新的h后再进行一次同样的操作，分别右移7位和4位，具体的哈希函数优劣就不去研究了     * 这个方法可以尽量减少碰撞     */    static int hash(int h) {        h ^= (h >>> 20) ^ (h >>> 12);        return h ^ (h >>> 7) ^ (h >>> 4);    }

再散列rehash过程

当哈希表的容量超过默认容量时，必须调整table的大小。
当容量已经达到最大可能值时，那么该方法就将容量调整到Integer.MAX_VALUE返回，这时，需要创建一个新的table数组，将table数组的元素转移到新的table数组中。

/**     * 再散列过程     * Rehashes the contents of this map into a new array with a     * larger capacity.  This method is called automatically when the     * number of keys in this map reaches its threshold.     */    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);    }    /**     * 把当前Entry[]表的全部元素转移到新的table中     */    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);            }        }    }