HashMap

无序，不重复，可以有一个null 的key，value可以有多个（线程不安全）

1.将负载因子赋值默认 0.75f，不做任何操作 transient Node<K,V>[] table;

public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

2.一个参数的构造函数指定初始数组长度，调用两个参数的构造函数用指定的长度与默认的负载因子0.75

public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

3.将负载因子初始化，初始容量变量初始化（tableSizeFor经过此函数进行运算，使得指定长度变成其相近的2的n次冥）｛到此为止，构造函数都是准备，没有对数组的创建｝｛长度为什么会被调整为2的n次冥，主要是利用哈希计算位置的算法其长度为2的n次冥能减少哈希碰撞｝

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

4.处理对指定的容量数，进行无符号位运算，在异或运算，1位+2位+4位+8位+16位=31，将int（32位）的高位都移动到低位啦。（在判断调教过的容量数是否合法）得到距离指定容量最近的2的n次冥的数作为指定容量

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

5.使用hash(key)计算key的哈希值，哈希值，key，value传递到putVal函数进行操作添加（false, true暂时不管你）

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

6.检查key，null就是哈希为0，通过hashCode得到哈希值，进行二次散列返还（二次散列，还是为了减少哈希碰撞）

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

7.核心代码（判断数组是否为空，空则扩容，不空则判断添加的元素对应位置是否有内容，没有直接添加，最后记录判断（容量是否扩容），有则判断是否形同，同则替换，不同则判断是否为树，为树则以树法添加，不是则以链法添加）

链法添加：死循环判断下一个元素是否为空，空直接添加

不为空，判断是否为相同key，同结束，到后面替换

不同继续循环｛新元素挂最后，或者相同key替换value｝

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    //空的数组，用于使用暂存底层数组
    Node<K,V>[] tab;
    //空结点用于暂存哈希冲突，或者就是保存头部节点，用于调整
    Node<K,V> p; 
    //两个变量，记录数组长度，与key计算出来的位置
    int n, i;
    /*
    * 将底层数组（table）{默认为null}赋值给原本定义的空数组（tab），在将长度保存与n
    * 判断底层数组是否为null或者长度为0，进行扩容resize()，得到新数组给原本定义的空数组（tab）将长度给n
    */
    if ((tab = table) == null || (n = tab.length) == 0)
        //扩容方法下一小点展开
        n = (tab = resize()).length;
    //i = (n - 1) & hash通过哈希计算位置记录在i，判断i位置是否为null（是否哈希冲突）
    if ((p = tab[i = (n - 1) & hash]) == null)
        //没有冲突直接赋值
        tab[i] = newNode(hash, key, value, null);
    //=======================出现冲突解决冲突=============================================
    else {
        //创建空节点，记录冲突节点
        Node<K,V> e;
        //创建key，记录冲突k
        K k;
        /*
        *判断是否与第一个冲突，｛比较哈希值，与地址｝（是否为同一个对象），在比较内容，是否保存东西相同
        *冲突则直接到最后替换
        */
        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 {
            //从头开始死循环next判断冲突
            for (int binCount = 0; ; ++binCount) {
                //如果下一个节点没有东西直接链式挂上（没有啦就是循环到最后拉，尾插法）
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //添加进去后判断会否大于等于7，0到7刚好是8，就是大于等于八个元素
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        //链式转树
                        treeifyBin(tab, hash);
                    break;
                }
                //在链比较是否key相同｛多方面比较｝，同直接结束在后面替换
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //判断是否为空，默认为空，key相同则赋值相同节点，否则不赋值，所以，不为空则为key相同
        if (e != null) { // existing mapping for key
            //新旧value替换
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    //==========================冲突解决完毕==========================================
    /////////////////////////////======>正常添加,记录操作次数，判断容量是否达到阈值，返回为空
    //记录集合操作数加一
    ++modCount;
    //判断容量是否达到阈值
    if (++size > threshold)
        //达到扩容
        resize();
    afterNodeInsertion(evict);
    return null;
}

7.resize()扩容方法详解，初始化的指定量int oldThr = threshold，第一次用于初始化，之后用作阈值

判断老数组是否为空，不为空取出容量与阈值都左位运算相当于乘以2（如果容量乘2后还小于16 阈值到后面容量乘以 0.75f计算得到），容量确定直接到后面进行扩容

否则（数组为空）判断指定量是否为空（就是是否为0）不为空则直接用指定量作为初始容量扩容，指定量变成阈值量记录阈值，指定量新容量乘以0.75f

数组为空，指定量为空（0），直接使用默认16，与默认0.75f*16得到阈值（此刻指定量直接成为阈值使用）

新数组创建后，判断老数组是否有东西，有则拷贝无则结束return newTab;

final Node<K,V>[] resize() {
    //定义数组，保存原数组
    Node<K,V>[] oldTab = table;
    //判断老数组是否为空，空则为0，不空则得到长度保存到oldCap中
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //记录指定长度（带参构造进行赋值过），没有指定的话默认为0
    int oldThr = threshold;
    //定义新的长度，与指定长度初始为0
    int newCap, newThr = 0;
    //oldCap原数组长度，有长度则进入
    if (oldCap > 0) {
        //判断会否超过最大容量是则Integer.MAX_VALUE记录到指定长度中
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //没有达到最大长度，并且老容量大于16
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            //新的指定容量等于老的指定容量定的左移1位（2倍数）
            newThr = oldThr << 1; // double threshold
    }
    //原数组不大于零（原数组为空）判断指定容量是否有值，有则给新的容量
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    //数组为空，没有指定容量，新容量定义为16，指定量定义为16*0.75f
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //判断新的指定量（阈值）为0不，为这以新容量*0.75f求得指定量
    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;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((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;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

1