HashMap源码解析（JDK1.8）

来源：
https://mp.weixin.qq.com/s/I6KFAO1n9IQznieUZL95YA
https://mp.weixin.qq.com/s/MVOqN8mbUtaU0ClUmS4qKw
Java编程的逻辑

HashMap

1 Map接口定义

public interface Map<K,V> {
    int size();

    boolean isEmpty();

    boolean containsKey(Object key);

    boolean containsValue(Object value);

    V get(Object key);

    V put(K key, V value);

    V remove(Object key);

    void putAll(Map<? extends K, ? extends V> m);

    void clear();
    
    Set<K> keySet();

    Collection<V> values();

    Set<Map.Entry<K, V>> entrySet();
    
    interface Entry<K,V> {
        
        K getKey();

        V getValue();

        V setValue(V value);

        boolean equals(Object o);


        int hashCode();

        public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getKey().compareTo(c2.getKey());
        }

        public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getValue().compareTo(c2.getValue());
        }

        public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
        }

        public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
        }
    }

    boolean equals(Object o);

    int hashCode();

    default V getOrDefault(Object key, V defaultValue) {
        V v;
        return (((v = get(key)) != null) || containsKey(key)) ? v : defaultValue;
    }

    default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }

    default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
        Objects.requireNonNull(function);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }

            // ise thrown from function is not a cme.
            v = function.apply(k, v);

            try {
                entry.setValue(v);
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
        }
    }
    
    default V putIfAbsent(K key, V value) {
        V v = get(key);
        if (v == null) {
            v = put(key, value);
        }

        return v;
    }

    default boolean remove(Object key, Object value) {
        Object curValue = get(key);
        if (!Objects.equals(curValue, value) ||
            (curValue == null && !containsKey(key))) {
            return false;
        }
        remove(key);
        return true;
    }

    default boolean replace(K key, V oldValue, V newValue) {
        Object curValue = get(key);
        if (!Objects.equals(curValue, oldValue) ||
            (curValue == null && !containsKey(key))) {
            return false;
        }
        put(key, newValue);
        return true;
    }

    default V replace(K key, V value) {
        V curValue;
        if (((curValue = get(key)) != null) || containsKey(key)) {
            curValue = put(key, value);
        }
        return curValue;
    }

    default V computeIfAbsent(K key,
            Function<? super K, ? extends V> mappingFunction) {
        Objects.requireNonNull(mappingFunction);
        V v;
        if ((v = get(key)) == null) {
            V newValue;
            if ((newValue = mappingFunction.apply(key)) != null) {
                put(key, newValue);
                return newValue;
            }
        }

        return v;
    }

    default V computeIfPresent(K key,
            BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        V oldValue;
        if ((oldValue = get(key)) != null) {
            V newValue = remappingFunction.apply(key, oldValue);
            if (newValue != null) {
                put(key, newValue);
                return newValue;
            } else {
                remove(key);
                return null;
            }
        } else {
            return null;
        }
    }

    default V compute(K key,
            BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        V oldValue = get(key);

        V newValue = remappingFunction.apply(key, oldValue);
        if (newValue == null) {
            // delete mapping
            if (oldValue != null || containsKey(key)) {
                // something to remove
                remove(key);
                return null;
            } else {
                // nothing to do. Leave things as they were.
                return null;
            }
        } else {
            // add or replace old mapping
            put(key, newValue);
            return newValue;
        }
    }
      
    default V merge(K key, V value,
            BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        Objects.requireNonNull(value);
        V oldValue = get(key);
        V newValue = (oldValue == null) ? value :
                   remappingFunction.apply(oldValue, value);
        if(newValue == null) {
            remove(key);
        } else {
            put(key, newValue);
        }
        return newValue;
    }
}

2 实现原理

2.1 成员属性源码分析一

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>,Cloneable,Serializable {
    private static final long serialVersionUID = 362498820763181265L;
    //HashMap的初始容量为16；
    //HashMap的容量指的是存储元素的数组大小，即桶的数量
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
    //HashMap的最大的容量：2^30
    static final int MAXIMUM_CAPACITY = 1 << 30;  
    //文字单独解析
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
	//当Node数组容量>=64的前提下，如果某一个桶中链表长度>=8，则会将链表结构转换成红黑树结构
    static final int TREEIFY_THRESHOLD = 8;
    static final int MIN_TREEIFY_CAPACITY = 64;
    //当红黑树中的节点数量<=6时，红黑树结构会转变为链表结构
    static final int UNTREEIFY_THRESHOLD = 6;
} 

• DEFAULT_LOAD_FACTOR

HashMap的负载因子，影响HashMap性能的参数之一，是时间和空间之间的权衡；
2.2节会讲到HashMap的元素存储在Node数组中，这个数组的大小这里称为“桶”的大小；
另外还有一个参数size指的是我们往HashMap中put了多少个元素；
当size > 桶的数量*DEFAULT_LOAD_FACTOR的时候，这时HashMap要进行扩容操作，也就是桶不能装满。

DEFAULT_LOAD_FACTOR用来衡量桶的利用率:
1.DEFAULT_LOAD_FACTOR较小时（桶的利用率较小）,这时浪费的空间较多（因为只能存储桶的数量DEFAULT_LOAD_FACTOR个元素，超过了就要进行扩容）,这种情况下往HashMap中put元素时发生冲突的概率也很小；
冲突：多个元素被put到了同一个桶中;冲突小时（可以认为一个桶中只有一个元素）put、get等HashMap的操作代价就很低，可以认为是O(1);
2.DEFAULT_LOAD_FACTOR很大时，桶的利用率较大的时候(注意可以大于1，因为冲突的元素是使用链表或者红黑树连接起来的)，此时空间利用率较高，这也意味着一个桶中存储了很多元素，这时HashMap的put、get等操作代价就相对较大，因为每一个put或get操作都变成了对链表或者红黑树的操作，代价肯定大于O(1)。

所以说DEFAULT_LOAD_FACTOR是空间和时间的一个平衡点：
DEFAULT_LOAD_FACTOR较小时，需要的空间较大，但是put和get的代价较小；
DEFAULT_LOAD_FACTOR较大时，需要的空间较小，但是put和get的代价较大）。

扩容操作就是把桶的数量*2，即把Node数组的大小调整为扩容前的2倍，为2倍的原因请看下文；

2.2 内部类Node源码分析

transient Node<K,V>[] table;

Node数组中每一个桶中存储的是Node链表，当链表长度>=8的时候并且Node数组的大小>=64，链表会变为红黑树结构（因为红黑树的增删改查复杂度是logn，链表是n，红黑树结构比链表代价更小）。

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash; //文字详细解析
    final K key;//保存map中的key
    V value;//保存map中的value
    Node<K,V> next;//下一个map节点

    Node(int hash, K key, V value ,Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
}

HashMap的内部类Node：HashMap的所有数据都保存在Node数组中

• hash属性

保存key的hashcode的值：key的hashcode ^ (key的hashcode>>>16)；

目的：主要是为了当我们往map中put(k,v)时减少hash冲突；
这个k,v键值对会被封装为Node，这个Node在Node数组中的位置为：index = hash&(n-1)；n为Node数组的长度；
为什么这样计算hash可以减少冲突呢？如果直接使用hashCode&(n-1)来计算index，此时hashCode的高位随机特性完全没有用到，因为n相对于hashcode的值很小，计算index的时候只能用到低16位。基于这一点，把hashcode高16位的值通过异或混合到hashCode的低16位（key的hashcode>>>16提供高16位，key的hashcode提供低16位），由此来增强hashCode低16位的随机性。

2.3 hash

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

HashMap允许key为null，null的hash为0（也意味着HashMap允许key为null的键值对）；
非null的key的hash高16位和低16位分别由：key的hashCode高16位和hashCode的高16位异或hashCode的低16位组成。
目的：主要是为了增强hash的随机性减少hash&(n-1)的随机性，即减小hash冲突，提高HashMap的性能。
所以HashMap的key的hashCode函数的实现对HashMap的性能影响较大，极端情况下所有key的hashCode都相同，这是HashMap的性能很糟糕！

2.4 tableSizeFor

static final int tableSizeFor(int cap) {
    //举例而言：n的第三位是1(从高位开始数)， 
    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;
}

在new HashMap的时候，如果我们传入了大小参数，这是HashMap会对我们传入的HashMap容量进行传到tableSizeFor函数处理；
这个函数主要功能是：返回一个数，这个数是大于等于cap并且是2的整数次幂的所有数中最小的那个，即返回一个最接近cap(>=cap)，并且是2的整数次幂的数。

具体逻辑如下:一个数是2的整数次幂，那么这个数减1的二进制就是一串掩码，即二进制从某位开始是一 串连续的1。所以掩码+1一定是2的整数次幂，这也是为什么n=cap-1的原因。

举例而言,假设：

n=00010000_00000000_00000000

1.n |= n >>> 1;//执行完后

//n=00011000_00000000_00000000

2.n |= n >>> 2;//执行完后

//n= 00011110_00000000_00000000

3,n |= n >>> 4;//执行完后

//n= 00011111_11100000_00000000

4.n |= n >>> 8;//执行完后

//n= 00011111_11111111_11100000

5.n |= n >>> 16;//执行完后

//n=00011111_11111111_11111111

6.返回n+1，(n+1)>=cap、为2的整数次幂，并且是与cap差值最小的那个数；
最后的n+1一定是2的整数次幂，并且一定是>=cap。

整体的思路就是：如果n的二进制的第k为1，那么经过上面四个‘|’运算后[0,k]位都变成了1,即：一连串连续的二进制‘1’(掩码)，最后n+1一定是2的整数次幂（如果不溢出）。

2.5 成员属性源码分析二

//我们往map中put的(k,v)都被封装在Node中，所有的Node都存放在table数组中
transient Node<K,V>[] table;
//用于返回keySet和values
transient Set<Map.Entry<K,V>> entrySet;
//保存map当前有多少个元素
transient int size;
//failFast机制
transient int modCount;

2.6 threshold属性

//文字详细讲解
int threshold;//门槛
//负载因子，见上面对DEFAULT_LOAD_FACTOR参数的讲解，默认值是0.75
final float loadFactor;

• threshold：扩容的门槛

创建HashMap时，该变量的值是：初始容量（2的整数次幂）,之后threshold的值是HashMap扩容的门限值：即当前table数组的长度 * loadfactor；
举个例子而言，如果我们传给HashMap构造器的容量大小为9，那么threshold初始值为16，在向HashMap中put第一个元素后，内部会创建长度为16的Node数组，并且threshold的值更新为16 * 0.75=12；
具体而言，当我们一直往HashMap里put元素的时候，如果put某个元素后，Node数组中元素个数为13，此时会触发扩容（因为数组中元素个数 > threshold了，即13 > threshold=12）；
扩容操作：将Node数组长度 * 2；并且将原来的所有元素迁移到新的Node数组中。

2.7 构造器

//构造器：指定map的大小，和loadfactor
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);
       //保存loadfactor
       this.loadFactor = loadFactor;
    /*注意，2.4有讲tableSizeFor函数，该函数返回值：>= initialCapacity、返回值是2的整数次幂
       并且得是满足上面两个条件的所有数值中最小的那个数。
     */
    this.threshold = tableSizeFor(initialCapacity);
}
/*
只指定HashMap容量的构造器，loadfactor使用的是默认的值:0.75
*/
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//无参构造器，默认loadfactor：0.75,
//默认的容量是16
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; 
}

从构造器中我们可以看到，HashMap是“懒加载”；
在构造器中值保留了相关保留的值，并没有初始化table< Node >数组，当我们向map中put第一个元素的时候，map才会进行初始化

2.8 get

//入口,返回对应的value
public V get(Object key) {
    Node<K,V> e;
        
    //hash函数：2.3
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

实质：进行链表或者红黑树遍历搜索指定key的节点的过程；

注意：HashMap的get函数的返回值不能判断一个key是否包含在map中，get返回null有可能是不包含该key，也有可能该key对应的value为null。HashMap中允许key为null，允许value为null。

2.9 getNode

//下面分析getNode函数
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab;
    Node<K,V> first, e;
    int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n-1) & hash]) != null) {
        if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
            //一次就匹配到了，直接返回，否则进行搜索
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                //红黑树搜索/查找
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                //链表搜索(查找)
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;//找到了就返回
            } while ((e = e.next) != null);
        }
    }
    return null;//没找到，返回null
}

注意getNode返回的类型是Node：当返回值为null时表示map中没有对应的key；
注意区分value是否为null，如果key对应的value为null的话，体现在getNode的返回值e.value为null，此时get函数返回值也是null；
也就是2.8所说的get函数不能判断map中是否有对应的key：get返回值为null时，可能不包含该key，也可能该key的value为null！
那么如何判断map中是否包含某个key呢？见下面contains函数分析。

• getNode函数细节分析

(n-1)&hash含义：当前key可能在的桶索引，put操作时也是将Node存放在index=(n-1)&hash位置。

主要逻辑：
如果table[index]处节点的key就是要找的key则直接返回该节点；
否则：在table[index]位置开始进行里面的搜索，搜索是否存在目标key的Node；
这里的搜索又分两种：链表搜索和红黑树搜索

2.10 contains

public boolean containsKey(Object key) {
    //注意与get函数区分，此函数返回null，则真正说明没有此键
    //我们往map中put的所有的<key,value>都被封装在Node中，如果Node都不存在显然一定不包含对应的key
    return getNode(hash(key), key) != null;
}   

2.11 put

//函数入口,两个参数：key和value
public V put(K key, V value) {
    /*注意前3个参数，后面2个参数这里不太重要，因为所有的put操作后面的2个参数默认值都一样 */
    return putVal(hash(key), key, value, false, true);
}
//put函数的核心处理函数
final V putVal(int hash, K key, V value, boolean onlyIfAbsent，boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; 
    int n, i;
    /*上面提到过HashMap是懒加载，所有put的时候要先检查table数组是否已经初始化了，没有初始化得先初始化table数组，保证table数组一定初始化了；resize函数由下文分析 */
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    /*到这里表示table数组一定初始化了；
与上面get函数相同，指定key的Node，会存储在在table数组的i=(n-1)&hash下标位置，get的时候也是从table数组的该位置搜索 */
    if ((p = tab[i = (n - 1) & hash]) == null)
        /*如果i位置还没有存储元素，则把当前的key，value封装为Node，存储在table[i]位置  */
        tab[i] = newNode(hash, key, value, null);
    else {
        /*
        如果table[i]位置已经有元素了，则接下来的流程是：
        首先判断链表或者二叉树中是否已经存在key的键值对：
        存在的话就更新它的value；不存在的话把当前的key，value插入到链表的末尾或者插入到红黑树中；
        如果链表或者红黑树中已经存在Node.key等于key，则e指向该Node，即e指向一个Node，或者说指向该Node的key属性与put时传入的key参数相等的那个Node，后面会更新e.value
         */
        Node<K,V> e; 
        K k;
        /*
        为什么get和put先判断p.hash==hash,下面的if条件中去掉hash的比较逻辑也是正确？因为hash的比较是两个整数的比较，比较的代价相对较小，key是泛型，对象的比较比整数比较代价大，所以先比较hash，hash相等再比较key
        */
        if(p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            /*
            e指向一个Node：该Node的key属性与put时传入的key参数相等的那个Node
            */
            e = p;
        else if (p instanceof TreeNode)
             /*
             红黑树的插入操作，如果已经存在该key的TreeNode，则返回该TreeNode，否则返回null
             */
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
         /*
         table[i]处存放的是链表，接下来和TreeNode类似在遍历链表过程中先判断当前的key是否已经存在，如果存在则令e指向该Node；否则将该Node插入到链表末尾，插入后判断链表长度是否>=8，是的话要进行额外操作
          */
             //binCountt最后的值是链表的长度
            for (int binCount = 0;;++binCount) {
                if ((e = p.next) == null) {
                /*
                遍历到了链表最后一个元素,接下来执行链表的插入操作，先封装为Node,再插入p指向的是链表最后一个节点，将待插入的Node置为p.next，就完成了单链表的插入
                  */
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                     /*
                     TREEIFY_THRESHOLD值是8,binCount>=7,然后又插入了一个新节点，链表长度>=8，这时要么进行扩容操作，要么把链表结构转为红黑树结构。我们接下会分析treeifyBin的源码实现
                     */
                    	treeifyBin(tab, hash);
                    break;
                }
                 /*
                  当p不是指向链表末尾的时候：先判断p.key是否等于key，等于的话表示当前key已经存在了，令e指向p，停止遍历，下面会更新e的value;
                  */
				if (e.hash == hash && ((k = e.key) == key  || (key != null && key.equals(k))))
                	break;
                //不等的话准备下次遍历，令p=p.next，即p=e
                p = e;
            }
        }	
        if (e != null) {
        /*
       表示当前的key在put之前已经存在了，并且上面的逻辑保证:e已经指向了之前已经存在的Node，这时更新e.value就好。
         */
            //更新oldvalue
            V oldValue = e.value;
             /*
             onlyIfAbsent默是false，evict为true。onlyIfAbsent为true表示：如果之前已经存在key这个键值对了，那么后面再put这个key时，忽略这个操作，不更新先前的value。这里了解就好 
              */
            if (!onlyIfAbsent || oldValue == null)
                //更新e.value
                e.value = value;
                 /*
                这个函数的默认实现是“空”，即这个函数默认什么操作都不执行，那为什么要有它呢？ 这其实是个hook/钩子函数，主要在LinkedHashMap（HashMap子类）中使用，LinkedHashMap重写了这个函数。
                         */
            afterNodeAccess(e);
            //返回旧的value
            return oldValue;
        }
    }

    ++modCount;//failFast机制
    /*
       size保存的是当前HashMap中保存了多少个键值对，HashMap的size方法就是直接返回size
之前说过，threshold保存的是当前table数组长度*loadfactor，如果table数组中存储的Node数量大于threshold，这时候会进行扩容，即将table数组的容量翻倍。
        */
    if (++size > threshold)
        resize();
    //这也是一个hook函数，作用和afterNodeAccess一样
    afterNodeInsertion(evict);
    return null;
}  

2.12 treeifyBin

//将链表转换为红黑树结构
//在链表的插入操作后调用
final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; 
    Node<K,V> e;
    /*MIN_TREEIFY_CAPACITY值是64,也就是当链表长度>8的时候，有两种情况：如果table数组的长度<64,此时进行扩容操作;如果table数组的长度>64，此时进行链表转红黑树结构的操作.
    认为链表长度>8一定会转换成红黑树，这是不对的！
    */
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e=tab[index=(n-1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
} 

2.13 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;
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
         //正常扩容：newCap = oldCap << 1
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            //容量翻倍，扩容后的threshold自然也是*2
            newThr = oldThr << 1; 
    }
    else if (oldThr > 0) // 将初始容量设置为阈值
        newCap = oldThr;
    else {// 零初始阈值表示使用默认值；table数组初始化的时候会进入到这里
        //默认容量
        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);
    }
    threshold = newThr;//更新threshold
    @SuppressWarnings({"rawtypes","unchecked"})
    //扩容后的新数组
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;//赋值为容量翻倍的新数组
    if (oldTab != null) {//oldTab中的Node迁移到table中去
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    /*j这个桶位置只有一个元素，直接
        			rehash到table数组 
        			*/
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    /*如果是红黑树：也是将红黑树拆分为
      				两个链表，这里主要看链表的拆分，
      				两者逻辑一样*/
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    //链表的拆分
            		//第一个链表l1
                    Node<K,V> loHead = null, loTail = null;
                    //第二个链表l2
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            /*rehash到table[j]位置
                			将当前node连接到l1上  */
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            //将当前node连接到l2上
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        //l1放到table[j]位置
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        //l1放到table[j+oldCap]位置
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

• 有两种情况会调用当前函数

1.HashMap是懒加载，第一次调用HashMap的put方法的时候table还没初始化，这个时候会执行resize，进行table数组的初始化；
table数组的初始容量保存在threshold中（如果从构造器中传入的一个初始容量的话），如果创建HashMap的时候没有指定容量，那么table数组的初始容量是默认值：16。
即：初始化table数组的时候会执行resize函数
2.扩容的时候会执行resize函数，当size>threshold的时候会触发扩容，即执行resize方法，这时table数组的大小会翻倍。

• 注意我们每次扩容之后容量都是翻倍（ *2），所以HashMap的容量一定是2的整数次幂，那么HashMap的容量为什么一定得是2的整数次幂呢？

要知道原因，首先回顾我们put key的时候，每一个key会对应到一个桶里面，桶的索引是这样计算的： index = hash & (n-1)；

index的计算最为直观的想法是：hash%n，即通过取余的方式把当前的key、value键值对散列到各个桶中；那么这里为什么不用取余(%)的方式呢？

原因是CPU对位运算支持较好，即位运算速度很快；
另外,当n是2的整数次幂时：hash&(n-1)与hash%(n-1)是等价的，但是两者效率来讲是不同的，位运算的效率远高于%运算。

基于上面的原因，HashMap中使用的是hash&(n-1)。
这还带来了一个好处，就是将旧数组中的Node迁移到扩容后的新数组中的时候有一个很方便的特性：
HashMap使用table数组保存Node节点，所以table数组扩容的时候（数组扩容一定得是先重新开辟一个数组，然后把就数组中的元素重新散列（rehash）到新数组中去。

举一个例子来说明这个特性：下面以Hash初始容量n=16，默认loadfactor=0.75举例（其他2的整数次幂的容量也是类似的），默认容量：n=16，二进制：10000；n-1：15，n-1二进制：01111。某个时刻，map中元素大于16*0.75=12，即size>12。此时会发生扩容，即会新建了一个数组，容量为扩容前的两倍，newtab，len=32。

接下来我们需要把table中的Node搬移(rehash)到newtab。从table的i=0位置开始处理；
假设我们当前要处理table数组i索引位置的node，那这个node应该放在newtab的那个位置呢？
下面的hash表示node.key对应的hash值，也就等于node.hash属性值,另外为了简单，下面的hash只写出了8位（省略的高位的0），实际上hash是32位；

node在newtab中的索引：

index = hash % len=hash & (len-1)
=hash & (32 - 1)=hash & 31
=hash & (0x0001_1111)；

再看node在table数组中的索引计算：

i = hash & (16 - 1) = hash & 15
= hash & (0x0000_1111)。

注意观察两者的异同：

i = hash&(0x0000_1111);

index = hash&(0x0001_1111)

上面表达式有个特点：

index = hash & (0x0001_1111)
= hash & (0x0000_1111) | hash & (0x0001_0000)
= hash & (0x0000_1111) | hash & n)
= i + ( hash & n)

含义：

hash&n要么等于n要么等于0；
也就是：index要么等于i，要么等于i+n;
再具体一点：当hash&n0的时候，index=i;
当hash&nn的时候，index=i+n;

作用：

当我们把table[i]位置的所有Node迁移到newtab中去的时候，这里面的node要么在newtab的i位置（不变），要么在newtab的i+n位置；

也就是说我们可以这样处理：把table[i]这个桶中的node拆分为两个链表l1和l2：
如果hash&n==0，那么当前这个node被连接到l1链表；否则连接到l2链表；

这样下来，当遍历完table[i]处的所有node的时候，我们得到两个链表l1和l2；
令newtab[i]=l1,newtab[i+n]=l2,这就完成了table[i]位置所有node的迁移/rehash；

这也是HashMap中容量一定的是2的整数次幂带来的方便之处。