面试连环炮之HashMap（下）

面试连环炮之HashMap（下）-源码分析

文章前言：

​ 我们之前在上篇和中讲解了关于map的哈希冲突，和map的扩容问题，我们下篇就开始学习Hashmap1.8的源码，相信大家读完这篇文章后，可以对map底层更加的了解~

想查看更多的文章请关注公众号：IT巡游屋

JDK1.8的变化

相比于之前的版本，jdk1.8在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，并且容量大于64时，将链表转化为红黑树，以减少搜索时间。

JDK1.8 Map的变量介绍

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    // 序列号
    private static final long serialVersionUID = 362498820763181265L;    
    // 默认的初始容量是16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;   
    // 最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30; 
    // 默认的填充因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    // 当桶(bucket)上的结点数大于这个值时会转成红黑树
    static final int TREEIFY_THRESHOLD = 8; 
    // 当桶(bucket)上的结点数小于这个值时树转链表
    static final int UNTREEIFY_THRESHOLD = 6;
    // 桶中结构转化为红黑树对应的table的最小大小
    static final int MIN_TREEIFY_CAPACITY = 64;
    // 存储元素的数组，总是2的幂次倍
    transient Node<k,v>[] table; 
    // 存放具体元素的集
    transient Set<map.entry<k,v>> entrySet;
    // 存放元素的个数，注意这个不等于数组的长度。
    transient int size;
    // 每次扩容和更改map结构的计数器
    transient int modCount;   
    // 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
    int threshold;
    // 填充因子
    final float loadFactor;
}

• loadFactor加载因子

  loadFactor加载因子是控制数组存放数据的疏密程度，loadFactor越趋近于1，那么 数组中存放的数据(entry)也就越多，也就越密，也就是会让链表的长度增加，load Factor越小，也就是趋近于0，

  loadFactor太大导致查找元素效率低，太小导致数组的利用率低，存放的数据会很分散。loadFactor的默认值为0.75f是官方给出的一个比较好的临界值。

• threshold

  threshold = capacity * loadFactor，当size>=threshold的时候，那么就要考虑对数组的扩增了，也就是说，这个的意思就是 衡量数组是否需要扩增的一个标准。

JDK1.8 Map的构造方法

map的初始化并不会构建好结构，而是在put方法时，构建出来，这也就是我们经常说的延迟加载

public HashMap() {
        //设置加载因子
        this.loadFactor = DEFAULT_LOAD_FACTOR;  
}
public HashMap(int initialCapacity) {
     // 当指定了容量时，指定加载因子
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
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;
        this.threshold = tableSizeFor(initialCapacity);
    }

JDK1.8Map的put方法

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // table未初始化或者长度为0，进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
    //resize方法有两个作用，1.是进行初始化 2.进行扩容，扩容的问题我们在上一篇已经研究过了，一会我们来看map的初始化
        n = (tab = resize()).length;
    //利用哈希算法，求出当前新存入的这个元素在map中的哪个位置，并且，如果当前这个节点没有元素，那么会利用尾插法，将元素放入到该节点下
    // 注：map1.8采用的是尾插，1.7采用的是头插
    // 尾插：指新来的元素放在链表的最后处
    // 头插：指新来的元素放在链表的头部位置
    // 设计：我们通常认为，map后插入的元素，通常会被先使用到，所以map1.7时，选择将后插入的元素放到链表中的第头部，优化查询效率，而头插法这种方式会导致出现死循环问题，该问题，我们在最终篇时给大家进行讲解，而map1.8时，就采用的是尾插，没有采用头插了
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 比较桶中第一个元素(数组中的结点)的hash值相等，key相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            // 将第一个元素赋值给e，用e来记录
            e = p;
        //  如果上述条件不满足，则判断是否是颗树
        else if (p instanceof TreeNode)
            //按照树的方式来处理它，放入树中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        // 在此处：则满足了如下三个条件
        // 1.此处必有元素
        // 2.hash和eqauls不等
        // 3.该处不是一颗树
        // 如果满足以上三点，则真相只有一个！！该处是一个链表
        else {
             // 遍历，在链表最末插入结点
            for (int binCount = 0; ; ++binCount) {
                 // 到达链表的尾部
                if ((e = p.next) == null) {
                    //插入元素，尾插
                    p.next = newNode(hash, key, value, null);
                    // 注意：如果当链表长度大于8，同时在treeifyBin 还有一个条件即：容量大小要大于64，因为如果链表长度过长，哪怕超过8，但是整体的的容量并不多，此时的链表长度完全可以通过扩容来转换，没必要去花时间去把他转换成树
                    if (binCount >= TREEIFY_THRESHOLD - 1) 
                        treeifyBin(tab, hash);
                    break;
                }
                 // 判断链表中结点的key值与插入的元素的key值是否相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                   // 相等，跳出循环
                    break;
                // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
                p = e;
            }
        }
        // 表示在桶中找到key值、hash值与插入元素相等的结点
        if (e != null) { 
            // 当出现了相同key，会进行key不变value覆盖的理论依据，就在此处
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
   // 结构性修改
    ++modCount;
    // 扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

JDK1.8的resize方法非扩容部分

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        // 如果此时是数组是null，或者是长度为0时
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // 此时阈值也是0 
        int oldThr = threshold;
        // 新的容量和新的阈值也是0 
        int newCap, newThr = 0;
        // 在初始化时，不会进来
        if (oldCap > 0) {
            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
        }
        // 初始化时，也不会进来
        else if (oldThr > 0)  
            newCap = oldThr;
        else {      
            // if没进去，else if 没进去，当然就跑到这儿来咯
            // 将16 赋值给newCap
            newCap = DEFAULT_INITIAL_CAPACITY;
            // 新的阈值
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 初始化时不会进来
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        // 阈值有了~~~16 
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            //初始化了~ 并且容量是16 
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
}