认真研究HashMap的初始化和扩容机制

 public HashMap(int initialCapacity);
 public HashMap() ;
 public HashMap(Map<? extends K, ? extends V> m)
 public HashMap(int initialCapacity, float loadFactor)

代码如下所示，这里先说明一点，扩容的本质是获取新的容量和新的临界值，并对链表或者树进行转化。
final

((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
// int bit = oldCap   int index = j
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
    TreeNode<K,V> b = this;
    // Relink into lo and hi lists, preserving order
    //数组索引位置没有发生变化的
    TreeNode<K,V> loHead = null, loTail = null;
    //数组索引位置发生变化的
    TreeNode<K,V> hiHead = null, hiTail = null;
    int lc = 0, hc = 0;
    for (TreeNode<K,V> e = b, next; e != null; e = next) {
        next = (TreeNode<K,V>)e.next;
        e.next = null;
        //(e.hash & oldCap) == 0
        if ((e.hash & bit) == 0) {
            if ((e.prev = loTail) == null)
                loHead = e;
            else
                loTail.next = e;
            loTail = e;//通过这两步形成链表
            ++lc;
        }
        else {
            if ((e.prev = hiTail) == null)
                hiHead = e;
            else
                hiTail.next = e;
            hiTail = e;
            ++hc;
        }
    }
// 到这里for循环结束，也是件检索整个树结点
    if (loHead != null) {
      // UNTREEIFY_THRESHOLD = 6
        if (lc <= UNTREEIFY_THRESHOLD)
          // 转为链表
            tab[index] = loHead.untreeify(map);
        else {
            tab[index] = loHead;
            //如果hiHead 为null，则说明所有节点位置没有发生变化，
            //其本身就是一棵树，无需再次处理
            if (hiHead != null) 
                loHead.treeify(tab);
        }
    }
    if (hiHead != null) {
      //转为链表 tab[index + bit]其实就是tab[j+oldCap]
        if (hc <= UNTREEIFY_THRESHOLD)
          //转为链表
            tab[index + bit] = hiHead.untreeify(map);
        else {
            tab[index + bit] = hiHead;
            if (loHead != null)
              //转为树，思路同上
                hiHead.treeify(tab);
        }
    }
}

public HashMap(int initialCapacity, float loadFactor)；
public HashMap(int initialCapacity)；
public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
public HashMap(Map<? extends K, ? extends V> m)

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);
    // Find a power of 2 >= initialCapacity
    // 这里使用了while，jdk1.8采取的位运算
    int capacity = 1;
    while (capacity < initialCapacity)
        capacity <<= 1;
    this.loadFactor = loadFactor;
    threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    // 实例化时就为数组分配了空间
    table = new Entry[capacity];
    useAltHashing = sun.misc.VM.isBooted() &&
            (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
    init();
}

void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    //对旧容量做了最大值判断，如果已经达到最大值则更新threshold ，直接return
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
  //实例化新数组，容量为newCapacity
    Entry[] newTable = new Entry[newCapacity];
    boolean oldAltHashing = useAltHashing;
    useAltHashing |= sun.misc.VM.isBooted() &&
            (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
    boolean rehash = oldAltHashing ^ useAltHashing;
    // 数据的转化-旧数组的数据转到新数组中
    transfer(newTable, rehash);
    //table指向新数组
    table = newTable;
    //计算并更新threshold 
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    //遍历数组中的每个“链表”
    for (Entry<K,V> e : table) {
        while(null != e) {
          //对链表中的每个结点进行循环
            Entry<K,V> next = e.next;
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            // h & (length-1) 计算当前结点在新数组中的位置
            int i = indexFor(e.hash, newCapacity);
            //头插法，会形成倒排效果
            e.next = newTable[i];
            newTable[i] = e;
            //更新 e 为下一个结点
            e = next;
        }
    }
}

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;//⑦
  }