HashMap的一些相关

1.底层数据结构

HashMap的底层数据结构有两个阶段，在jdk1.8以前是由数组和链表组成，jdk1.8及以后是由数组，链表和红黑树组成。
首先数组是一个Entry数组，源码中对于Entry的定义如下：

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
    
    public final K getKey()        { return key; }
    
    public final V getValue()      { return value; }
    
    public final String toString() { return key + "=" + value; }
    
    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }
    
    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }
    
    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

即Entry是一个包含Key，Value以及其get和set方法的一个数据结构。
因为在Hash过程中可能会有Hash一致的情况，即每一个数组的位置有可能包括不止一个Entry节点，因此引入了链表的结构，使其能够在同一个数组位置链接多个Hash值相同的节点。又因为当链表过长的时候，遍历会消耗大量的时间，因此jdk1.8后将过长（长度超过8）的链表转化为红黑树的结构以提高查询的效率。

2.构造的过程

先看一个HashMap的构造方法：

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);
}

首先构造方法中的参数initialCapacity和loadFactor都是非必须的，如果没有指定，则默认initialCapacity为16，loadFactor为0.75。从上面的代码可以看出默认的底层数组的大小是16，而因子是0.75，而且在执行构造方法的时候并没有为数组实际地分配空间，而是在执行put方法的时候才真正构建数组，分配空间。

3.put方法的执行过程

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;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break; 
                }
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

以上代码的逻辑可以参考下面的流程图：

4.resize的过程

• 保存原来的数据（容量大小，扩容阈值以及具体数据等等）

• 判断原本的容量。

  • 如果如果不是0，则证明已经初始化过。

    • 如果原先的容量大于最大容量，则将阈值设置为最大，返回原来的数组。
    • 如果新容量是旧容量右移一位得到的。新容量大于默认的16，小于最大容量，将阈值扩大为原来的两倍。
  • 如果是0，则初始化，并设置阈值。
• 初始阈值为0，表示采用默认初始化过程。
• 创建新容量的数组，容量为之前你的2倍。

• 采用循环遍历之前的数组、

  • 如果索引j处只有一个数据，则使用新的数组容量重新计算hash值，插入到新的数组的相应位置中去。
  • 如果索引j处是红黑树结构，采用红黑树的散列方式。
  • 如果索引j处是链表结构，使用链表的散列方式。