HashMap源码理解(JDK1.8)

HashMap类继承结构

从下面的代码和图中可以看出HashMap的类继承结构非常简单，也可以看出Map接口和Collection接口是两大不同的集合，曾经遇到过的面试题。并且HashMap没有实现Iterable迭代器接口，不能直接的遍历所有节点，所以其需要转换为Set集合（entrySet、keySet、valueSet）来遍历访问。

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

HashMap中的数据结构

HashMap中存储数据的结构是数组加上链表或者是数组加上红黑树。

在ArrayList中存储数据用的数组，在LinkedList中存储数据用的链表，这两种数据结构在查询某个数据的时候都会遍历数组或链表来找到相应的数据再返回，这样的时间复杂度将是O(n)。

如果有一种算法可以将一个元素算出一个对应不变的值，再利用数组的特性，将这个计算出来的特征值作为数组的下标索引，那么查找某个元素的时候只需计算出这个值即可通过数组取得这个元素，这样时间复杂度将是常数。这个计算出来的特征值由哈希算法也可叫做散列算法算出来的，被称为hash值或者散列值，由于这个值也代表了在数组中的下标位置，也被称为桶位。

一个元素唯一对应一个hash值，但多个元素可能hash值相同，那么谁该放入数组中的这个桶位呢，这个问题就是哈希碰撞问题。HashMap解决哈希碰撞问题的方法是链接法，将具有相同的hash值的元素（元素本身不同）追加在链表或树的尾部。

一些常量和成员变量

常量

/**
 * 默认的初始容量常数，为16，2的4次方。HashMap中的容量必须为2的幂
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

/**
 * 最大的容量，如果通过构造函数指定一个更高的容量值，那么将会使用此常量。
 */
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * 默认的负载因子，负载因子的意思是当存储的元素个数达到了总容量乘以负载因子，那么需要触发扩容来保证离散型
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 * 该常量表示数组桶位中链表的节点个数达到了该值，那么可以从链表转换为红黑树结构
 */
static final int TREEIFY_THRESHOLD = 8;

/**
 * 数组桶位中的红黑树节点低于此值那么转换为链表结构
 */
static final int UNTREEIFY_THRESHOLD = 6;

/**
 * 最小的树形化容量，当容量达到了该常量才能转换为树结构。意思是从链表转换为红黑树需要两个常量的条件满足，另一个是TREEIFY_THRESHOLD
 */
static final int MIN_TREEIFY_CAPACITY = 64;

成员变量

/**
 * 节点类型的数组，HashMap存储数据的关键。
 * 其数组长度必须是2的幂，在首次使用数组时会进行初始化。
 */
transient Node<K,V>[] table;

/**
 * 用于存储键值对的Set集合
 */
transient Set<Map.Entry<K,V>> entrySet;

/**
 * 键值对的个数，即tab数组中实际存储的节点的个数
 */
transient int size;

/**
 * 记录结构被改变的次数，该值会用于使用迭代器的时候保证结构未被改动
 */
transient int modCount;

/**
 * 扩容阈值，达到该大小时则需扩容。
 * 在初始化时也可能记录的是构造方法指定初始化容量的大小。
 */
int threshold;

/**
 * 记录负载因子
 */
final float loadFactor;

构造函数

默认的构造方法只会将HashMap的负载因子设置为默认值即0.75。

//默认的负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;

public HashMap() {
	this.loadFactor = DEFAULT_LOAD_FACTOR; 
}

该构造方法指定一个初始化的容量

/**
 * @param  initialCapacity 指定初始化数组的大小
 */
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

此构造函数可以指定初始的容量大小和负载因子

/**
* @param  initialCapacity 指定数组初始大小
* @param  loadFactor      负载因子
*/
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);
   this.loadFactor = loadFactor;
   //由于HashMap制定数组的容量只能是2的幂，所以需要对传入的初始容量进行规范化
   //赋值给成员变量threshold，表示下次初始化resize时需要初始化容量的大小
   this.threshold = tableSizeFor(initialCapacity);
}

/**
* 会根据给定的参数返回一个2的幂
*/
static final int tableSizeFor(int cap) {
   int n = cap - 1;
   n |= n >>> 1;
   n |= n >>> 2;
   n |= n >>> 4;
   n |= n >>> 8;
   n |= n >>> 16;
   return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

插值操作

通常调用put方法进行插入键值对的操作。下面对put跟进分析。

/**
 * 1. 在插值之前会先计算出key对象的hash值，这个值将用于计算在数组的桶的位置。
 * 2. 然后调用putVal方法
 */
public V put(K key, V value) {
	return putVal(hash(key), key, value, false, true);
}

/**
 * 计算hash值（散列函数），调用对象key的hashCode方法得到一个值与该值右移16位后的值进行异或运算
 * 在这里通过移位和异或运算hash值的目的是为了减少hash碰撞，增加散列程度
 * >>> 右移运算符号，高位补0
 */
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

/**
 * 插入操作的核心方法
 */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //1. 先判断当前数组表是否未被初始化，若没初始化那么分配默认大小的数组
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //2. 通过hash值和数组容量进行与操作算出桶位置（即数组下标），
    //根据桶位置判断是否有元素在其中，若没有直接新建节点放入桶中
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    //若桶中已经存在节点
    else {
        Node<K,V> e; K k;
        //3. 首先判断改节点中的key是否与需要插入的节点的key相同(通过hash值和equals方法判断)，
        //若相同则先利用e变量记录起来后续处理替换其中的value。
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //4. 如果节点key不与插入的key相同且节点的类型为红黑树的节点，那么调用红黑树的插入操作。
        //若树中有相同key值，那么会被返回，变量e也会记录
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        //5. 第3，4条件都不满足，那么认为节点类型是链表节点
        else {
            for (int binCount = 0; ; ++binCount) {
            	//若遍历至尾节点，直接创建节点添加至链表尾部
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //如果链表中的节点个数达到了树形化阈值，那么将链表转换为红黑树，提高查找效率
                    //注意在treeifyBin方法中还需数组的容量大小达到阈值64时才会转换。
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //如果遍历中找到相同的key，退出循环，此时e变量也记录着对应的相同节点
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //6. 如果变量e不为null，说明节点中存在着与当前key相同的key
        //使用新的value替换原来的value，返回旧value
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    //记录HashMap结构变化次数
    ++modCount;
    //增加存储的节点个数记录，若达到了扩容阈值，那么重新分配数组大小
    if (++size > threshold)
        resize();
    //插入节点完成后的回调方法
    afterNodeInsertion(evict);
    return null;
}

/**
 * 这是HashMap扩容数组大小的方法。
 * 调用此方法的几个场景：
 * 1. HashMap初始化时；
 * 2. 负载容量达到阈值（负载因子 * 数组大小）时；
 * 3. 当某个桶位存在的节点数大于需要转换为红黑树阈值但是负载的容量还没达到可以树形化的容量时
 */
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    //1. 如果容量大于0，说明不是初始化
    if (oldCap > 0) {
    	//如果大于了默认的最大容量，那么赋予属性threshold最大值，即不会再扩容
    	//threshold记录着下次需要扩容的阈值
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //否则的话，尝试将容量扩容至原来的两倍，如果成功，那么记录下次扩容的阈值，也是原来的两倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    //2. 如果容量不大于0但扩容的阈值大于0，说明在构造函数中手动指定了首次扩容的大小，使用新容量变量newCap记录
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    //3. 上面条件均不满足，说明是默认的初始化操作，全部赋予默认值
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //4. 如果新的扩容阈值没有赋值，赋值之
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    //赋予属性新的扩容阈值
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    //创建新的容量大小的数组
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    //5. 如果旧的数组不为null，那么需要遍历将原来的桶位节点重新散列在新的数组上
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                //如果桶位中只有一个节点，那么重新计算新桶位
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                //如果节点类型为树节点，交给其自身去遍历
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                //否则为链表
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        //如果(e.hash & oldCap) == 0，说明其应该在原来的桶位上。
                        //并使用变量loHead记录链表头部， loTail记录尾部
						//原因在下面详解
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        //否则的话应该具有新的桶位
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        //新的桶位是旧桶位的下标加上旧容量的大小
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

这里解释以下为什么(e.hash & oldCap) == 0，就说明其应该还在原来的桶位上。
首先明确HashMap容量的特点：1. 数组的大小一定是2的幂；2. 容量如果可以扩容那么是原来的2倍。
假设旧容量是8，其二进制则是01000
扩容后的值是16，其二进制是10000，
计算散列位置是： (容量 - 1) & hash。
那么：
新桶位 = (新容量 - 1) & hash = (旧容量 * 2 - 1) & hash = (旧容量 + (旧容量 - 1)) & hash
= (旧容量 & hash) + 旧桶位 = (e.hash & oldCap) + 旧桶位

这么一换算瞬间明白。

那么为什么(e.hash & oldCap) 不等于 0的时候，新桶位=旧桶位+旧容量 呢？
从上面推导的公式来看最终结果是： 新桶位 = (旧容量 & hash) + 旧桶位
HashMap的容量特性容量一定是2的幂， 所以：(旧容量 & hash) 要么等于0，要么等于旧容量。这里需要换算成二进制想一下。

这里也可以反向证明为什么要这么制定HashMap的容量，一切都是为了这后面的计算和代码实现方便。

查询操作

查询操作一般使用get(Object key)方法来根据指定的key来查询相应的value，下面跟进分析。

/**
 * 通过给定的key对象获取对应的value
 * 这里的key可以为null，HashMap中可以存储一个key为null的键
 */
public V get(Object key) {
    Node<K,V> e;
    //获取节点，其中hash(key)方法调用对象的hashcode并计算hash值且处理了key为null的情况。
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

/**
 * Implements Map.get and related methods
 *
 * @param hash hash for key
 * @param key the key
 * @return the node, or null if none
 */
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    //1.判断当前数组和相应的桶位是否有节点
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        //2.检查桶中的第一个节点是否与给定的key相同，通过hash值、变量的引用或equals方法确定。
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        //3.如果桶位中存在下一个节点
        if ((e = first.next) != null) {
        	//判断是否为红黑树节点，如果是交给其自身查找
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            //如果是链表，则遍历查找
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

删除操作

通常使用remove(Object key)方法对HashMap中存储的元素删除。

/**
 * 通过指定的key对象来删除HashMap中的键值对，并且会返回删除的key对应的value对象
 */
public V remove(Object key) {
    Node<K,V> e;
    //调用删除节点方法，如果有返回值那么返回节点的value对象
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

/**
 * 
 * @param key对象计算出来的hash值
 * @param key对象
 * @param value 需要匹配的value对象，当matchValue为true时才比较value是否相同
 * @param matchValue 如果为true，会与给定的value参数比较，相同才会删除
 * @param movable 删除指定节点后是否移动其它节点，如果为false则不移动，用在树节点中
 * @return 将会返回删除的节点, 如果没有找到对应的节点则返回null
 */
final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    //删除节点的思路：1.先查找到对应的节点；2.判断节点的类型，根据类型来执行不同的删除操作
    //这下面则是查找节点的过程，和getNode方法相似
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        //判断是否查找到node，并且判断是否需要匹配value对象相等
        //如果matchValue为true那么将会执行后面的或操作来判断value对象是否相等
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            //如果节点是红黑树节点，那么交给自身删除树节点
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            //如果节点是链表节点并且是链表头部，p变量记录的链表头部即桶位，那么将桶位指向下一个节点
            else if (node == p)
                tab[index] = node.next;
            //直接删除链表节点
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

修改操作

由于HashMap的数据结构保证了key对象不能重复，所以当要修改一个key对应的value时，可以直接使用put(K key, V value)方法来替换原来的value对象。
但是HashMap还是提供了修改value对象的方法。

@Override
/**
 * 通过指定key来替换value，但要满足oldValue也要匹配才会替换为newValue对象
 */
public boolean replace(K key, V oldValue, V newValue) {
    Node<K,V> e; V v;
    //通过getNode方法获取查找相应节点并判断value对象是否与传入的方法参数oldValue相等
    if ((e = getNode(hash(key), key)) != null &&
        ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
        e.value = newValue;
        afterNodeAccess(e);
        return true;
    }
    return false;
}

@Override
/**
 * 通过指定key来替换value
 */
public V replace(K key, V value) {
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) != null) {
        V oldValue = e.value;
        e.value = value;
        afterNodeAccess(e);
        return oldValue;
    }
    return null;
}

若有不足，请指点！