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

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

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            ……
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            ……
        }
        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;
        if (oldTab != null) {
            ……
        }
        return newTab;
    }

int index = hash % n;

int index = (n - 1) & hash;

n = 8 (二进制 1000)
hash = 10110100（十进制180）

n = 2^k
index = hash % n
q = hash / n = hash >>> k
hash = n * q + index

index = hash - ((hash >>> k) <<< k )
#代入示例的结果：
index = 10110100 - 10110000 = 00000100 = 4

final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                               int h, K k, V v) {
    Class<?> kc = null;
    boolean searched = false;
    // 若本节点有父，则取真正root；否则this就是root
    TreeNode<K,V> root = (parent != null) ? root() : this;

    // 从根开始向下找插入位置或已存在的key
    for (TreeNode<K,V> p = root;;) {
        int dir, ph; K pk;

        // 1) 先比 hash，决定左右
        if ((ph = p.hash) > h)
            dir = -1;                  // 往左
        else if (ph < h)
            dir = 1;                   // 往右
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p;                  // 同一key，返回旧节点
        else if ((kc == null &&
                  (kc = comparableClassFor(k)) == null) ||
                 (dir = compareComparables(kc, k, pk)) == 0) {
            // hash相等且key不可比较(或比较结果为0)
            if (!searched) {
                // 只做一次：尝试在左右子树里再找同key
                TreeNode<K,V> q, ch;
                searched = true;
                if (((ch = p.left) != null &&
                     (q = ch.find(h, k, kc)) != null) ||
                    ((ch = p.right) != null &&
                     (q = ch.find(h, k, kc)) != null))
                    return q; // 找到了就直接返回
            }
            // 仍找不到，用平局打破策略确定左右
            dir = tieBreakOrder(k, pk);
        }

        TreeNode<K,V> xp = p;
        // 2) 若对应子树为空，落位插入
        if ((p = (dir <= 0) ? p.left : p.right) == null) {
            Node<K,V> xpn = xp.next; // 桶内链表的下一个
            // 同时创建树结点，并预置链表next指向xpn
            TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);

            // 接到树上
            if (dir <= 0) xp.left = x;
            else          xp.right = x;

            // 接到桶内双向链表上
            xp.next = x;
            x.parent = x.prev = xp;
            if (xpn != null)
                ((TreeNode<K,V>)xpn).prev = x;

            // 红黑树平衡 & 把根移到桶表头
            moveRootToFront(tab, balanceInsertion(root, x));
            return null;               // 新插入，返回null
        }
        // 否则继续向下
    }
}

void afterNodeAccess(Node<K,V> e) { // move node to last
    LinkedHashMap.Entry<K,V> last;
    if (accessOrder && (last = tail) != e) {
        // 把被访问的节点移到链表尾部，保持“最近访问的在后面”
        LinkedHashMap.Entry<K,V> p = e.prev, n = e.next;
        if (p != null) p.next = n;
        if (n != null) n.prev = p;
        if (tail == e) tail = p;
        if (head == e) head = n;
        e.next = null;
        e.prev = tail;
        if (tail != null)
            tail.next = e;
        else
            head = e;
        tail = e;
    }
}

void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry<K,V> first;
    if (evict && (first = head) != null && removeEldestEntry(first))
        removeNode(first.hash, first.key, null, false, true);
}