hashmap

1.HashMap构造函数：
//无参的构造函数

public HashMap() {
    //加载负载因子；
    //注意 这里并没有初始化shreshold,默认还是为0
	this.loadFactor = DEFAULT_LOAD_FACTOR;  
}

//传入容量参数的构造函数

public HashMap(int initialCapacity) {
    //调用下边的构造函数
	this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

//传入容量参数和负载因子的构造函数

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

//传入一个Map，核心是使用了putAll方法

public HashMap(Map<? extends K, ? extends V> m) {
	this.loadFactor = DEFAULT_LOAD_FACTOR;
	putMapEntries(m, false);
}

用户在构造HashMap时，不管有没有传入容量参数，HashMap在初始化的时候其容量都是为0；

因为HashMap使用的懒加载机制，只有你第一次向HashMap中添加元素(put)时，才进行第一次的容量设置

1.如果用户没有传入容量参数，那么调用的是无参的构造函数进行初始化，此时容量为0；

2.如果用户传入了容量参数，那么也只是将容量参数initialCapacity通过tableSizeFor方法找出距离该initialCapacity最近的2的幂次方数值，然后将该数值赋给了扩容阀值threshold；

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

1.HashMap开始put元素：
1.1 首先调用Val函数
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
1.2 putVal函数：
1.如果链表数组table为空，则直接进行扩容

2.用hash%n（等于(n-1) & hash），计算出要插入的元素A存放在table数组的哪个位置

如果该位置为空，则生成一个链表节点放入

3.如果该位置已经存在节点元素p

    3.1 如果p节点的key与要插入的元素A的key相同，则重新将p的value置为A的value

    3.2 如果不同，并且p节点为红黑树的子节点，则插入到红黑树中

    3.3 如果不同，且p元素为链表节点,则遍历该链表，如果出现3.1情况，直接break，没有的话          就插入到链表尾部

    3.4 如果链表长度大于等于8，调用treeifyBin函数尝试扩容，如果数组长度小于64则扩容，如          果大于64，则该链表转为红黑树

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，进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // (n - 1) & hash 确定元素存放在哪个桶中，桶为空，新生成结点放入桶中(此时，这个结点是放在数组中)
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 桶中已经存在元素（处理hash冲突）
    else {
        Node<K,V> e; K k;
        // 判断table[i]中的元素是否与插入的key一样，若相同那就直接使用插入的值p替换掉旧的值e。
        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);
                    // 结点数量达到阈值(默认为 8 )，执行 treeifyBin 方法
                    // 这个方法会根据 HashMap 数组来决定是否转换为红黑树。
                    // 只有当数组长度大于或者等于 64 的情况下，才会执行转换红黑树操作，以减少搜索时间。否则，就是只是对数组扩容。
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    // 跳出循环
                    break;
                }
                // 判断链表中结点的key值与插入的元素的key值是否相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等，跳出循环
                    break;
                // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
                p = e;
            }
        }
        // 表示在桶中找到key值、hash值与插入元素相等的结点
        if (e != null) {
            // 记录e的value
            V oldValue = e.value;
            // onlyIfAbsent为false或者旧值为null
            if (!onlyIfAbsent || oldValue == null)
                //用新值替换旧值
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            // 返回旧值
            return oldValue;
        }
    }
    // 修改的次数
    ++modCount;
    // 实际大小大于阈值则扩容
    if (++size > threshold)
        resize();
    // 插入后回调
    afterNodeInsertion(evict);
    return null;
}

1.3 插入元素后，可能会调用resize函数进行扩容：
1.如果数组table不为空，也就是oldCap>0，则说明已经被初始化过

    1.1 如果原来的容量大于2^31，则容量已经达到最大，无法扩容，直接返回

    1.2 如果扩容到两倍之后大于等于16且小于2^31（最大容量），则扩容到两倍

2.如果threshold>0

说明是通过传入容量参数(initialCapacity)的构造函数进行初始化的，newCap的值变为threshold，

在后面的判断中，threshold的默认值变为initialCapacity0.75，则newThr值为initialCapacity0.75

3.如果threshold=0，是调用的无参构造函数 ，threshold默认为0，则扩容到16，且决定是否扩容的newThr变量为默认容量*填充因子

4.如果newThr == 0，说明是走到2这个步骤的，也就是通过传入容量参数进行初始化的，则计算新的newThr

5.算出新的threshold(决定是否扩容,超过该值，则扩容)和newCap（数组容量），则开始新建一个扩容后的Node数组newTab，将oldTab的值移动到newTab中

遍历oldTab元素e，如果e不为空，则开始移动这一整个链表/红黑树的节点到newTab中。
如果当前元素e只有一个元素，则计算出放在newTab中的位置，也就是e.hash%newCap = e.hash&(newCap-1),再放入到newTab中。
如果当前元素e是红黑树节点，则调用split方法（在后面解释）
到这里，只可能是当前元素e有多个后继节点：
由于数组扩容了两倍，但是e.hash没有改变，会导致下标大于oldCap的位置是空着的，所以需要将e.hash小于oldCap的数组元素放入到原来的下标j中，将e.hash大于oldCap的元素放入到新的下标j+oldCap中
为什么这样，举个例子：e.hash=6,oldCap=5,则j=6%5=1，扩容后的数组长度为10，则 j=6%10=6，刚好等于j+oldCap。
将e.hash小于oldCap的数组元素,也就是低位的元素，通过loTail进行遍历，头节点 放入到loHead中， 同理，将e.hash大于oldCap的数组元素,也就是高位的元素，通 过HiTail进行遍历，头节点放入到HiHead中。
最后，将数组i中的各个链表元素一分为二，低位的去j，高位的去j + oldCap，返回 newTab数组

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) {
            // MAXIMUM_CAPACITY: 如果原来的容量大于2^31，则无法扩容，直接返回
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 如果扩容2倍之后大于等于16且小于2^31，则扩容一倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        // 如果threshold,table容量*(loadFactor=0.75)>0，说明初始的容量放在threshold中
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        // 如果原来的表还没有被初始化，threshold默认为0，则扩容到16
        // 且决定是否扩容的newThr变量为默认容量*填充因子  
        else {  // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 计算新的threshold（决定是否扩容的变量，新容量>table容量*(loadFactor=0.75)，则扩                
        // 容）
        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) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                // 如果当前数组i元素有值
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    // 如果当前数组i元素只有这一个值，塞到新数组中
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    // 如果当前数组i元素是红黑树的结点
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    // 如果当前数组i元素的链表有多个值
                    // 注意 数组扩容了两倍
                    // 但是e.hash不变，元素数组下标又需要改变
                // 所以需要将e.hash小于oldCap容量的放置在原来的下标j中，
                    // 将e.hash大于oldCap的放置在新的下标(j+ oldCap)中
                     else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            // 如果e.hash小于oldCap
                            // loTail类似于cur指针
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            // 如果e.hash大于等于oldCap
                            // hiTail类似于cur指针
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        // 将数组i中的各个链表元素一分为二，低位的去j，高位的去j + oldCap
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

((TreeNode<K,V>)e).split(this, newTab, j, oldCap)方法：

 final void split(HashMap<K,V> map, HashMap.Node<K,V>[] tab, int index, int bit)
    {
        HashMap.TreeNode<K,V> b = this;
        // Relink into lo and hi lists, preserving order
        HashMap.TreeNode<K,V> loHead = null, loTail = null;
        HashMap.TreeNode<K,V> hiHead = null, hiTail = null;
        int lc = 0, hc = 0;
        // 数组[i]的各个链表节点的值，低位转到数组[i]中，高位转换到数组[i+bit]中，
        // 有可能低位或者高位也要转换为红黑树
        for (HashMap.TreeNode<K,V> e = b, next; e != null; e = next)
        {
            next = (HashMap.TreeNode<K,V>)e.next;
            e.next = null;
            //  与resize函数类似++lc和++hc统计低位链表和高位链表的值
            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;
            }
        }
 
        if (loHead != null) {
            // 如果低位的头不为空，且链表里面的个数小于等于6，把treeNode类型转换为Node类型，又将红黑树转为链表
            if (lc <= UNTREEIFY_THRESHOLD)
                tab[index] = loHead.untreeify(map);
            // 如果低位的头不为空，且链表里面的个数大于6，则重新生成红黑树
            else {
                tab[index] = loHead;
                // 如果低位的头不为空，且链表里面的个数大于6，高位为空的话，就把不用多此一举了，就让它全部在低位就行了
                if (hiHead != null) // (else is already treeified)
                    loHead.treeify(tab);
            }
        }
        if (hiHead != null) {
            if (hc <= UNTREEIFY_THRESHOLD)
                tab[index + bit] = hiHead.untreeify(map);
            else {
                tab[index + bit] = hiHead;
                if (loHead != null)
                    hiHead.treeify(tab);
            }
        }
    }