HashMap源码Java8

常量

// 默认初始容量2的4次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认负载因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 由链表变成红黑树的门槛8
static final int TREEIFY_THRESHOLD = 8;
// 由链表不变成红黑树的门槛6
static final int UNTREEIFY_THRESHOLD = 6;
// 最小树化容量64
static final int MIN_TREEIFY_CAPACITY = 64;

Node是HashMap的内部类，实现了Map.Entry接口

// Node是单向链表，实现了Map.Entry接口
static class Node<K,V> implements Map.Entry<K,V> {
	// hash值
    final int hash;
    // key值
    final K key;
    // value值
    V value;
    // 链接下一个结点
    Node<K,V> next;
	
	// 构造函数，hash值，key，value，next
    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

	// 获取key值
    public final K getKey()        { return key; }
    // 获取value值
    public final V getValue()      { return value; }
    // 返回key=value形式的值
    public final String toString() { return key + "=" + value; }

	// 返回hashCode值
    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

	// 更新value值，并返回原value值
    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

	// 判断两个Node是否相等
    public final boolean equals(Object o) {
    	// 与自身比较
        if (o == this)
            return true;
        // instanceof是判断左边对象是否是右边类的实例
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            // 如果key和value都相等返回true
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

红黑树 TreeNode<K,V>

// 红黑树继承LinkedHashMap.Entry
// 链表转红黑树，并不是达到8个Node节点的阈值就进行转换，
// 而是要判断一下整个数据结构中的Node数量是否大于64，
// 大于才会转，小于就会用扩容数组的方式代替红黑树的转换。
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
	// 父结点
    TreeNode<K,V> parent;  // red-black tree links
    // 左结点
    TreeNode<K,V> left;
    // 右结点
    TreeNode<K,V> right;
    // 上一个同级结点
    TreeNode<K,V> prev;    // needed to unlink next upon deletion
    // 颜色
    boolean red;
    // 构造方法
    TreeNode(int hash, K key, V val, Node<K,V> next) {
        super(hash, key, val, next);
    }

    /**
     * Returns root of tree containing this node.
     * 返回当前结点的根节点
     */
    final TreeNode<K,V> root() {
        for (TreeNode<K,V> r = this, p;;) {
            if ((p = r.parent) == null)
                return r;
            r = p;
        }
    }
}

putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)

1. 根据(n - 1) & hash找到位置
2. 若该位置为空，直接插入，返回null
3. 若已经是红黑树了，直接插入/更新操作
4. 若该位置是一个链表，遍历是否有与其相等的key.hash和key，如果没有则采用尾插法新增结点，返回null，若有替换value返回原value

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，扩容，赋值给n，新table赋值给tab
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 根据hash值选位置，赋值给p，若为空直接插入
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 判断p的hash值与要插入的hash值是否相等，key是否一样
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            // 成立p赋值给e
            e = p;
        // p是否属于TreeNode
        else if (p instanceof TreeNode)
        	// 属于直接插入
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
        	// binCount统计原位置上的链长
            for (int binCount = 0; ; ++binCount) {
            	// 当是最后一个结点的时候插入，原最后一个结点赋值给e
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 判断是否可以树化
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // e的hash值与要插入的hash值相等，key相等，key不为null，break
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // e不为null，代表上面的循环并未遍历结束
        if (e != null) { // existing mapping for key
            // 获取原e的值
            V oldValue = e.value;
            // 原e的值为null替换，或者onlyIfAbsent 为false替换
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 插入结束size大于threshold扩容
    if (++size > threshold)
        resize();
    // 插入后回调
    afterNodeInsertion(evict);
    return null;
}

treeifyBin(Node<K,V>[] tab, int hash)

// tab就是hashMap的数组
// 进入方法的前提 binCount >= TREEIFY_THRESHOLD - 1，原位置不为空，传进来的key也不为空
final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    // 如果tab为null或者tab的长度小于树化的最小限制，则扩容
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    // 那么下面的判断是一定成立的
    // e是选中位置的原头结点
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
        	// 原头结点变成树结点
            TreeNode<K,V> p = replacementTreeNode(e, null);
            // tl第一次的时候一定为null，p赋值给hd
            if (tl == null)
                hd = p;
            else {
            // 除第一次pl为空，其他皆进入else
            	// 从第二个结点开始
            	// 双向链表链接，依次尾部添加
                p.prev = tl;
                tl.next = p;
            }
            // p赋值给tl
            tl = p;
        } while ((e = e.next) != null);
        // hd赋值给tab[index]，一定不为空
        if ((tab[index] = hd) != null)
        	// 树化
            hd.treeify(tab);
    }
}

treeify(Node<K,V>[] tab)

// 双向链表转化为红黑树
final void treeify(Node<K,V>[] tab) {
	// 定义红黑树的根节点
    TreeNode<K,V> root = null;
    // 从TreeNode双向链表的头结点开始逐个遍历
    for (TreeNode<K,V> x = this, next; x != null; x = next) {
    	// 头结点的下一个结点
        next = (TreeNode<K,V>)x.next;
        // x的左孩子和右孩子置为空
        x.left = x.right = null;
        // 根节点初始化，颜色为黑色
        if (root == null) {
            x.parent = null;
            x.red = false;
            root = x;
        }
        else {
        	// 获取x的key
            K k = x.key;
            // 获取x的hash值
            int h = x.hash;
            Class<?> kc = null;
            // 从根遍历红黑树
            for (TreeNode<K,V> p = root;;) {
                int dir, ph;
                // 获取p的key
                K pk = p.key;
                // 逐个结点的hash值与h比较
                // p的hash值大于h值的时候dir为-1
                if ((ph = p.hash) > h)
                    dir = -1;
                // 小于的时候dir为1
                else if (ph < h)
                    dir = 1;
                // 当前红黑树结点的key等于双向链表的key
                else if ((kc == null &&
                          (kc = comparableClassFor(k)) == null) ||
                         (dir = compareComparables(kc, k, pk)) == 0)
                    // 如果key值也一致则比较className和identityHashCode
                    dir = tieBreakOrder(k, pk);

                // p赋值给xp
                TreeNode<K,V> xp = p;
                // 如果p是叶子结点，代表结点x找到了要插入的位置
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                	// 原p点是x的父结点
                    x.parent = xp;
                    // x的hash值小于红黑树结点p的hash值的时候，x放左边
                    if (dir <= 0)
                        xp.left = x;
                    else
                    // 否则放右边
                        xp.right = x;
                    // 红黑树中插入元素，需要进行平衡调整(过程和TreeMap调整逻辑一模一样)
                    root = balanceInsertion(root, x);
                    break;
                }
            }
        }
    }
    // 将TreeNode双向链表转化为红黑树结构之后，
    // 由于红黑树是基于根节点进行查找，所以必须将红黑树的根节点作为数组当前位置的元素
    moveRootToFront(tab, root);
}

moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root)

// 将红黑树的根节点作为数组当前位置的元素
// TreeNode既是一个红黑树的结构，也是一个双链表结构
// 这个方法做的事情，就是保证树的根节点一定也要成为链表的首节点
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
    int n;
    // 根节点不为null，tab不为null，tab的length大于0
    if (root != null && tab != null && (n = tab.length) > 0) {
        // 找到红黑树根结点在tab上的位置
        int index = (n - 1) & root.hash;
        // 获取原数值
        TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
        // 与红黑树根结点不相等时
        if (root != first) {
        	// 定义根节点的后一个节点
            Node<K,V> rn;
            // 替换为红黑树根结点
            tab[index] = root;
            // 获取根节点对象的前一个结点
            TreeNode<K,V> rp = root.prev;
            // 将红黑树根结点前后相连
            // 红黑树根结点的next结点不为null
            if ((rn = root.next) != null)
            	// root后结点的前结点指向root的前结点，相当于把root从链表中删除
                ((TreeNode<K,V>)rn).prev = rp;
            // 如果root前结点不为空
            if (rp != null)
            	// root前结点的后结点指向root的后结点
                rp.next = rn;
            // 如果数组该位置上原来的元素不为空
            if (first != null)
            	// 这个原有的元素的前结点 指向root，相当于root目前位于链表的首位
                first.prev = root;
            // 原来第一个结点现在作为root的下一个结点，变成第二个结点
            root.next = first;
            // 首节点没有前结点
            root.prev = null;
        }
        // 校验TreeNode对象是否满足红黑树和双链表的特性
        assert checkInvariants(root);
    }
}

resize()

// 扩容
final Node<K,V>[] resize() {
	// 原数组
    Node<K,V>[] oldTab = table;
    // 获取原数组容量
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 原阈值
    int oldThr = threshold;
    int newCap, newThr = 0;
    // 原容量大于0
    if (oldCap > 0) {
    	// 若原容量大于等于最大容量
        if (oldCap >= MAXIMUM_CAPACITY) {
        	// Integer.MAX_VALUE赋值给threshold
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 若原容量扩大一倍后小于最大容量，且原容量大于等于默认初始容量
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 新阈值为原阈值一倍
            newThr = oldThr << 1; // double threshold
    }
    // 若原容量不大于0，原阈值大于0
    else if (oldThr > 0) // 初始容量已设置为阈值
        // 原阈值赋值给新容量
        newCap = oldThr;
    else {               // 零初始阈值表示使用默认值
        // 新容量为默认容量
        newCap = DEFAULT_INITIAL_CAPACITY;
        // 新阈值为默认负载因子×默认容量
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 新阈值为0
    if (newThr == 0) {
    	// 新容量×负载因子
        float ft = (float)newCap * loadFactor;
        // 新容量小于最大容量并且ft小于最大容量，新阈值为ft，否则为Integer.MAX_VALUE
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    // 新阈值赋值给threshold 
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    // 新数组
    table = newTab;
    /*
		上面总结：
		如果是最开始还没有元素的情况：
			1.如果初始化的时候带了参数
				（HashMap(int initialCapacity, float loadFactor)），
                 那么newCap就是你的initialCapacity参数
                 threshold就是 (int)(initialCapacity*loadFactor)
             2、否则就按默认的算 initialCapacity = 16，threshold = 12
            如果已经有元素了，那么直接扩容2倍，如果
            oldCap >= DEFAULT_INITIAL_CAPACITY了，那么threshold也扩大两倍
	*/
	// 如果原数组不为null
    if (oldTab != null) {
    	// 循环原数组
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            // 原数组不为null，赋值给e
            if ((e = oldTab[j]) != null) {
            	// 原数组置为null
                oldTab[j] = null;
                // 没有后续链表，计算在新的数组中的位置，赋值
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                // 若是红黑树，
                else if (e instanceof TreeNode)
                	// split的源码在下面
                    ((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;
                    // next结点
                    Node<K,V> next;
                    do {
                    	// 取e的后继结点赋值给e变量
                        next = e.next;
                        // 按位与，若为0
                        if ((e.hash & oldCap) == 0) {
                            // 若低位尾结点为null说明还未放结点
                            if (loTail == null)
                                // 设置低位头结点
                                loHead = e;
                            // 否则
                            else
                            	// 连接到低位尾结点后
                                loTail.next = e;
                            // 把e结点赋值给低位尾结点
                            loTail = e;
                        }
                        // 按位与不为0
                        else {
                        	// 若高位尾结点为null说明还未放结点
                            if (hiTail == null)
                                // 设置高位头结点
                                hiHead = e;
                            // 否则
                            else
                            	// 连接到高位尾结点后
                                hiTail.next = e;
                            // 把e结点赋值给高位尾结点
                            hiTail = e;
                        }
                    // 循环直到没有下一个结点为止
                    } while ((e = next) != null);
                    // 如果低位尾结点不为null
                    if (loTail != null) {
                        // 低位尾结点的next设置为null
                        loTail.next = null;
                        // 把头结点赋值给新数组对应的下标
                        newTab[j] = loHead;
                    }
                    // 如果高位结点不为null
                    if (hiTail != null) {
                    	// 高位尾结点的next设置为null
                        hiTail.next = null;
                        // 把头结点赋值给下标为[原下标+原数组长度]的数组
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit)

// map需要扩容的HashMap；tab新创建的数组；index旧数组的索引；bit旧数组长度（一定是2的幂次数）
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
    // 做个赋值，因为这里是((TreeNode<K,V>)e)这个对象调用split()方法，
    // 所以this就是指(TreeNode<K,V>)e对象，所以才能类型对应赋值
    TreeNode<K,V> b = this;
    // 重新链接到lo和hi列表，保留顺序
    // 设置低位头结点和低位尾结点
    TreeNode<K,V> loHead = null, loTail = null;
    // 设置高位首结点和高位尾结点
    TreeNode<K,V> hiHead = null, hiTail = null;
    // 定义两个变量，后面比较用，它们的大小决定了红黑树是否要转回链表
    int lc = 0, hc = 0;
    // 从e开始对整个红黑树遍历
    for (TreeNode<K,V> e = b, next; e != null; e = next) {
        // 取e的下一个结点赋值给next遍历
        next = (TreeNode<K,V>)e.next;
        // e的next置为null
        e.next = null;
        // 按位与运算，按照结果拉出两条链表
        // 如果与运算得0
        if ((e.hash & bit) == 0) {
        	// 若loTail为null，也就是低位链表为null的时候
            if ((e.prev = loTail) == null)
                // e赋值给低位头结点
                loHead = e;
            // 低位链表不为null的时候
            else
                // 接到低位链表后
                loTail.next = e;
            // e就是低位链表尾结点
            loTail = e;
            // 数量加1
            ++lc;
        }
        // 与运算不得0
        else {
        	// 若hiTail为null，也就是高位链表为null的时候
            if ((e.prev = hiTail) == null)
                // e赋值给高位头结点
                hiHead = e;
            // 高位链表不为null的时候
            else
                // 接到高位链表后
                hiTail.next = e;
            // e就是高位链表尾结点
            hiTail = e;
            // 数量加1
            ++hc;
        }
    }
	// 如果低位链表头结点不为null
    if (loHead != null) {
    	// 如果lc小于树化阈值
        if (lc <= UNTREEIFY_THRESHOLD)
            // 从红黑树转为链表，迁移到新数组中下标不变
            tab[index] = loHead.untreeify(map);
        // 不小于
        else {
        	// 低位链表迁移到新数组中下标不变
            tab[index] = loHead;
            // 如果hiHead为空代表，整个树没有变化，直接移植就行
            if (hiHead != null) // (else is already treeified)
                // 重建新的红黑树
                loHead.treeify(tab);
        }
    }
    // 如果高位链表头结点不为null
    if (hiHead != null) {
    	// 如果hc小于树化阈值
        if (hc <= UNTREEIFY_THRESHOLD)
        	// 从红黑树转为链表，迁移到新数组中下标不变
            tab[index + bit] = hiHead.untreeify(map);
        // 不小于
        else {
        	// 高位链表迁移到新数组中下标不变
            tab[index + bit] = hiHead;
            // 如果loHead为空代表，整个树没有变化，直接移植就行
            if (loHead != null)
                // 重建新的红黑树
                hiHead.treeify(tab);
        }
    }
}

untreeify(HashMap<K,V> map)

// map是需要退树化的HashMap
final Node<K,V> untreeify(HashMap<K,V> map) {
	// 设置头节点和尾结点
    Node<K,V> hd = null, tl = null;
    // Node结点调用的untreeify，所以this就是调用方法的结点，循环直到结束
    for (Node<K,V> q = this; q != null; q = q.next) {
    	// 将TreeNode转换成Node
        Node<K,V> p = map.replacementNode(q, null);
        // 尾结点为null说明链表是空的
        if (tl == null)
            hd = p;
        // 否则在链表后添加
        else
            tl.next = p;
        // 每次的p都是尾结点
        tl = p;
    }
    return hd;
}

get(Object key)

// 返回指定的key映射的value，如果value为null，则返回null
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

getNode(int hash, Object key)

// 根据key的哈希值和key获取对应的节点
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 数组不为空，长度大于0，根据hash值定位的数组下标位置不为空
    // 并把数组表表对应的第一个Node赋值给first
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 如果第一个Node就相等，返回
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // first有后继Node，赋值给e
        if ((e = first.next) != null) {
        	// 如果是TreeNode类型的调用getTreeNode
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 不是TreeNode类型的，循环遍历，找到就返回
            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映射的node
public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable)

// matchValue 如果为true，则value也作为确定被删除的node的条件之一
// movable 如果为false，删除node时不会删除其他node
final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    // 数组不为空，且定位下标的数组不为空，数组内结点赋值给p，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;
        // 如果第一个是要删除的结点，赋值给node
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        // p的next结点不为空
        else if ((e = p.next) != null) {
        	// p若是TreeNode类型
            if (p instanceof TreeNode)
            	// 调用getTreeNode查找
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
            // 循环遍历，找到了赋值给node
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    // 把当前节点p指向e，这一步是让p存储的永远下一次循环里e的父节点，如果下一次e匹配上了，那么p就是node的父节点
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        // 如果得到的node不为null且(matchValue为false||node.value和参数value匹配)
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            // 如果ndoe类型是TreeNode
            if (node instanceof TreeNode)
            	//使用红黑树的删除方法删除node
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            // 如果该节点不是TreeNode对象，node == p 的意思是该node节点就是首节点
            else if (node == p)
                tab[index] = node.next;
            // 如果node节点不是首节点，此时p是node的父节点，
            // 由于要删除node，所有只需要把p的下一个节点指向到node的下一个节点即可把node从链表中删除了
            else
                p.next = node.next;
            // 修改次数加1
            ++modCount;
            // 元素个数减1
            --size;
            // 调用afterNodeRemoval方法，该方法HashMap没有任何实现逻辑，目的是为了让子类根据需要自行覆写
            afterNodeRemoval(node);
            // 返回删除的node
            return node;
        }
    }
    // 返回空
    return null;
}

思考题
为什么resize之后，元素的位置要么是在原位置，要么是在原位置加原数组长度的位置？
HashMap的数组长度恒定为2的n次方
首先要知道oldCap的长度都是2的次幂，比如16，32，转换成二进制的话，它的有效最高位是1，低位都是0，拿16做个🌰：

0000 0000 0000 0000 0000 0000 0001 0000
如果oldCap都是这样只有有效最高位是1，其余都是0的二进制的话，那么其实e.hash的二进制真正能够参与到运算的有效位数就是oldCap的最高位到最低位的位数，比如oldCap是16的话，那e.hash的真正有效位数就是5位

下面来做个按位与运算，只有相同的二进制数位上，都为1才是1，否则都是0:
1111 1010 0000 1111 0000 1111 1100 1111 ---->e.hash的二进制
0000 0000 0000 0000 0000 0000 0001 0000 -----16的二进制

0000 0000 0000 0000 0000 0000 0000 0000 —>0

再换个e.hash
1111 1010 0000 1111 0000 1111 1101 1111 ---->第二个e.hash的二进制
0000 0000 0000 0000 0000 0000 0001 0000 -----16的二进制

0000 0000 0000 0000 0000 0000 0001 0000 ---->16

通过以上两个运算可以发现，只有e.hash与oldCap对应的有效高位上的值是1，运算结果才不为0，否则都是0。

数组长度之前为16，所以看下以上的两个e.hash对数组长度取模e.hash & (16-1)获取索引的结果是多少:
1111 1010 0000 1111 0000 1111 1100 1111 ---->e.hash的二进制
0000 0000 0000 0000 0000 0000 0000 1111 -----(16-1)的二进制

0000 0000 0000 0000 0000 0000 0000 1111 ---->15

1111 1010 0000 1111 0000 1111 1101 1111 ---->第二个e.hash的二进制
0000 0000 0000 0000 0000 0000 0000 1111 -----(16-1)的二进制

0000 0000 0000 0000 0000 0000 0000 1111 ----15

这是假设数组长度已经扩容成了32，把以上的两个e.hash对数组长度取模e.hash & (32-1))获取索引的结果是多少:

1111 1010 0000 1111 0000 1111 1100 1111 ---->e.hash的二进制
0000 0000 0000 0000 0000 0000 0001 1111 -----(32-1)的二进制

0000 0000 0000 0000 0000 0000 0000 1111 ---->15

1111 1010 0000 1111 0000 1111 1101 1111 ---->第二个e.hash的二进制
0000 0000 0000 0000 0000 0000 0001 1111 -----(32-1)的二进制

0000 0000 0000 0000 0000 0000 00001 1111 ----> 31

通过上述运算就可以发现，e.hash与oldCap对应的有效高位上的值是0的话，哪怕扩容了，新数组索引还是不变，还是15，而如果e.hash与oldCap对应的有效高位上的值是1的话，那这个元素在新数组的下标位置就等于【原数组下标位置+原数组长度】=【15+16】=31。这样就通过这个运算把原来的一条链表拆成了两条链表，然后这两条链表各自归属到新数组中对应的位置。

• 借鉴

https://blog.csdn.net/weixin_42340670/article/details/80555860
https://blog.csdn.net/weixin_38106322/article/details/104422422