学习HashMap

0.static final int tableSizeFor(int cap)

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

介绍一下 n |= n >>>1;  , 这个|=相当于 n = n | n>>>1 ，这个 >>>是无符号右移的意思

先说作用：获取最小的大于等于cap的2的次幂的值，例如，如果cap是7最后返回8，如果cap是8也是返回8，如果cap是9就返回16。

下面详细分析：我们只关注最高位，n写成二进制之后最高位一定是1，所以我们能写成1xx...，执行了n |= n >>>1; 一定是 11xx... ，然后执行 n |= n >>> 2; 一定是 1111xx... ，相信大家看出规律了为啥是无符号右移 1次 2次 4次 8次 16次，因为这样能把最高位的1平铺开，那为啥到16就停止了呢，因为int类型4个字节32位，最高位是1的话移动这些次数正好能32位全是1。

1.HashMap基于Map接口实现，元素以键值对的方式存储，并且允许使用null键和null值这点和hashTable区别hashTable不允许key为null执行的时候会报空指针异常， 如果键值是null在执行put方法的时候就会被放在第一个位置，hashMap中key不可以重复所以在插入的时候如果有相同的key就会把之前的value替换掉，因为 hashMap存放数据是根据hash算法存储的是无序的，所以hashMap不能保证放入元素的顺序

2.hashMap是线程不安全的因为它里面的代码并没有用synchronized同步，这点和hashTable区别hashTabe用了synchronized同步了

3.初始容量与扩容：

HashMap的初始容量为16，Hashtable初始容量为11，两者的填充因子默认都是0.75。

HashMap扩容时是当前容量翻倍即:capacity*2，Hashtable扩容时是容量翻倍+1即:capacity*2+1。

4.计算hash的方法：

Hashtable计算hash是直接使用key的hashcode对table数组的长度直接进行取模

int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;

HashMap计算hash对key的hashcode进行了二次hash，以获得更好的散列值，然后对table数组长度取模。

jdk 1.7

int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);

static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
 
 static int indexFor(int h, int length) {
        return h & (length-1);

jdk 1.8

HashMap 的hash优化
static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
举个例子
key="ykx"
key的hashCode是=119718  这是个10进制数
原始hashCode对应二进制11101001110100110==00000000000000011101001110100110
然后我再向右位移16位后的二进制==00000000000000000000000000000001 
异或运算
    0000000000000001 1101001110100110
    0000000000000000 0000000000000001
    0000000000000001 1101001110100111==119719 这个就是最终的hash值

优化点在哪

HashMap在get方法去获取值时是这样的
    hash(key)&(n-1) 进行与运算而找到数组位置
    0000000000000001 1101001110100111 上面优化后的hash值 hashMap默认数组长度16
    0000000000000000 0000000000001111 &
    0000000000000000 0000000000000111 =7
    这就是最终的位置下标  只要数组长度是2的n次方  你会发现：119719%16与119719&(16-1)的值时相同的

因为与运算的性能会比取模效率高。

其实这里最重要的几个点就是在算hash值时高是16位与低16进行了异或运算（因为很有可能有两个不同的值hash高16位不相同低16位相同）。(h = key.hashCode()) ^ (h >>> 16)这样就能使HashMap寻址运算时低16位包含了高16位与低16 的特征，因为在寻址的时候大多数都是低16位在运算，因为数组长度减1的数字大小一般情况都比较小。所以在get寻址时基本都是低16在运算，尽量避免hash冲突，寻址时用与运算代替取模运算也是比较大的优化，只要当HashMap的数组长度是2的n次方那么我们算出来的hash值取模这个长度等于与运算这个长度减1的值。

可以看到hashTable和hashMap获取数组下标分别是是 int index = (hash & 0x7FFFFFFF) % tab.length; 和  int index= hash & (length-1);

当length总是 2 的n次方时，h& (length-1)运算等价于h%length，但&比%效率高

那么 a % b 操作为什么等于 a & ( b - 1 )呢? (前提是b等于2的n次幂)

举例说明:
若 a = 10 , b = 8 , 10与8取余应得2.
8的二进制为: 1000 ; 7的二进制为: 0111.
也就是说-----2的n次幂减一这样的数的二进制都是如0000111111这样前半部分是0后半部分是1的形式.
所以, 用2的n次幂减一这样的数 & 另一个数就相当于 这个数取余 (%) 2的n次幂

为什么用2的n次幂减一这样的数 & 另一个数就相当于 这个数取余 (%) 2的n次幂？

上面已经解释了2的n次幂减一这样的数的二进制都是如0000111111这样前半部分是0后半部分是1的形式，这种形式可以保留余数，那为啥保留的这个就是余数呢？

答案是右移，除以2的n次幂，就是右移n位，右移出去的那些就是余数。

hashMap的数组长度总是2的n次方原因是：初始化的时候无参构造默认长度是16，指定长度的构造会经过处理，取大于等于指定长度最接近的2的n次方的数，例如指定19最后就是32，因为 16<19<32,扩容的时候是数组长度和门阈值都变成原来的2倍。源码分析为什么HashMap的table长度一定是2的整次幂_散居闲人的博客-CSDN博客

5.HashMap的数据存储结构：HashMap底层实现是由hash表（数组）和链表（当不同的key计算的分布在数组上的位置一样时（哈希值%数组长度）如果数组的这个位置已经有元素了就外链一个链表）或红黑树（1.8后当链表长度大于8时因为查询慢就会换成红黑树）

（1）.HashMap采用Entry数组来存储key-value对，每一个键值对组成了一个Entry实体，Entry类实际上是一个单向的链表结构，它具有Next指针，可以连接下一个Entry实体，以此来解决Hash冲突的问题。

（2） jdk1.7：（头插法）后加的在前面，先加的移下（如果A先加在table[i]，B通过hash值算出的位置和A相同也是table[i]并且B的key和A不同则table[i]=B,B.Next = A），这种情况叫碰撞。这种碰撞的情况应尽量避免，否存一个索引中链表的数据大量时，该索引当再次插入一个对象时equals比较全部影响效率。这时我们将equals和hashcode方法重写的严谨点，这种还是避免不了，因为数组的索引值有限。因此hashMap提供了加载因子避免碰撞，默认0.75，当元素到达现有的hash表的75%时扩容。一旦扩充就会重新排序hash表，减少碰撞概率。

       jdk1.8后用的是尾插法：后加的往后链(如果A先加在table[i],B通过hash值算出的位置和A相同也是table[i]并且B的key和A不同则A.Next = B)，jdk1.8中的HashMap存储结构是由数组、链表、红黑树这三种数据结构形成，红黑树查询删除快新增慢。存储结构下图所示，根据key的hash与table长度确定table位置，同一个位置的key以链表形式存储，超过一定限制链表转为树。数组的具体存取规则是tab[(n-1) & hash],其中tab为node数组，n为数组的长度，hash为key的hash值。

(3)put方法的源码解析：

public put(K key, V value) 
{
 // 调用hash(key)计算出key的hash值
    return putVal(hash(key), key, value, false, true);
}

static final int hash(Object key) {
    int h;
    // 如果key为null，则hash值为0，否则调用key的hashCode()方法
    // 并让高16位与整个hash异或，这样做是为了使计算出的hash更分散
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

/*
Parameters:
    hash hash for key
    key the key
    value the value to put
    onlyIfAbsent if true, don't change existing value
    evict if false, the table is in creation mode.
Returns:
    previous value, or null if none
*/
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为空，或者还没有元素时，则扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 如果首结点值为空，则创建一个新的首结点。
    // 注意：(n - 1) & hash才是真正的hash值，也就是存储在table位置的index。在1.6中是封装成indexFor函数。
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {    // 到这儿了，就说明碰撞了，那么就要开始处理碰撞。
            Node<K,V> e; K k;
            // 如果在首结点与我们待插入的元素有相同的hash和key值，则先记录。
            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) {
                            //这是如果遍历完链表发现没有相同的key，则在链表最后插入（尾插法）
                            p.next = newNode(hash, key, value, null);
                            // 当遍历的结点数目大于8时，则采取树化结构。
                            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                treeifyBin(tab, hash);
                                break;
                        }
                        // 如果找到与我们待插入的元素具有相同的hash和key值的结点，则停止遍历。此时e已经记录了该结点
                        if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                            break;
                        p = e;
                    }
                }
            // 表明，记录到具有相同元素的结点
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);  // 这个是空函数，可以由用户根据需要覆盖
                return oldValue;
            }
        }
    ++modCount;
    // 当结点数+1大于threshold时，则进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict); // 这个是空函数，可以由用户根据需要覆盖
    return null;
}

（1）计算key的hash值；

（2）如果桶（数组）数量为0，则初始化桶；

（3）如果key所在的桶没有元素，则直接插入；

（4）如果key所在的桶中的第一个元素的key与待插入的key相同，说明找到了元素，转后续流程（9）处理；

（5）如果第一个元素是树节点，则调用树节点的putTreeVal()寻找元素或插入树节点；

（6）如果不是以上三种情况，则遍历桶对应的链表查找key是否存在于链表中；

（7）如果找到了对应key的元素，则转后续流程（9）处理；

（8）如果没找到对应key的元素，则在链表最后插入一个新节点并判断是否需要树化；

（9）如果找到了对应key的元素，则判断是否需要替换旧值，并直接返回旧值；

（10）如果插入了元素，则数量加1并判断是否需要扩容；

1.判断数组是否为空，为空进行初始化。
2.不为空，计算key的哈希值，然后通过（hash&（数组长度 -1））计算出key在数组中的下标index。
3.查看table[index]是否为空，为空就利用传入的key和value构造一个新的Node节点存入table[index]
4.table[index]不为空，说明发生了哈希冲突，然后查看key是否相同，相同就用新的value替换掉原来的值。
5.如果key不相同，然后判断当前节点是不是树形节点，是的话查找树中是否存在元素的key与传入的key相等，相等就用新的value值替换，不存在就按照红黑树的规则将封装后的node节点加入红黑树，然后经过变色，左旋，右旋等一系列操作使该数重新符合红黑树的规则。
6.如果当前节点不是树形节点，那就是链表，遍历这个链表，看是否存在元素的key与传入的key相等，相等就用新的value值替换，不存在就将该元素加入到链表尾部。判断链表长度是否大于8，大于八转为红黑树。
7.插入完成后总结点数加1，判断节点数是否大于扩容阀值，大于就就行扩容。

resize()方法

调用resize（）方法，扩容的条件：

条件：初始化、存储的元素个数大于阈值（数组总长度*填充因子）、在树化的时候如果数组长度小于64就会扩容

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;
        } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 如果旧容量的两倍小于最大容量并且旧容量大于默认初始容量（16），则容量扩大为两部，扩容门槛也扩大为两倍
            newThr = oldThr << 1; // double threshold
    } else if (oldThr > 0) // initial capacity was placed in threshold
        // 使用非默认构造方法创建的map，第一次插入元素会走到这里
        // 如果旧容量为0且旧扩容门槛大于0，则把新容量赋值为旧门槛
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        // 调用默认构造方法创建的map，第一次插入元素会走到这里
        // 如果旧容量旧扩容门槛都是0，说明还未初始化过，则初始化容量为默认容量，扩容门槛为默认容量*默认装载因子
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        // 如果新扩容门槛为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;
            // 如果桶中第一个元素不为空，赋值给e
            if ((e = oldTab[j]) != null) {
                // 清空旧桶，便于GC回收  
                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
                    // 如果这个链表不止一个元素且不是一颗树
                    // 则分化成两个链表插入到新的桶中去
                    // 比如，假如原来容量为4，3、7、11、15这四个元素都在三号桶中
                    // 现在扩容到8，则3和11还是在三号桶，7和15要搬移到七号桶中去
                    // 也就是分化成了两个链表
                    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) == 0的元素放在低位链表中
                        // 比如，3 & 4 == 0
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        } else {
                            // (e.hash & oldCap) != 0的元素放在高位链表中
                            // 比如，7 & 4 != 0
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 遍历完成分化成两个链表了
                    // 低位链表在新桶中的位置与旧桶一样（即3和11还在三号桶中）
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 高位链表在新桶中的位置正好是原来的位置加上旧容量（即7和15搬移到七号桶了）
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

（1）如果使用是默认构造方法，则第一次插入元素时初始化为默认值，容量为16，扩容门槛为12；

（2）如果使用的是非默认构造方法，则第一次插入元素时初始化容量等于扩容门槛，扩容门槛在构造方法里等于传入容量向上最近的2的n次方；

（3）如果旧容量大于0，则新容量等于旧容量的2倍，但不超过最大容量2的30次方，新扩容门槛为旧扩容门槛的2倍；

（4）创建一个新容量的桶；

（5）搬移元素，原链表分化成两个链表，低位链表存储在原来桶的位置，高位链表搬移到原来桶的位置加旧容量的位置；

上面需要注意的是，链表处理的时候，有一个判断(e.hash & oldCap) == 0，用这个判断来区分是否变了位置，为啥这样判断：前提我们知道oldCap一定是2的n次幂，而且扩容之后newCap=oldCap*2所以oldCap如果写成2进制应该是1后面n个0而newCap则是1后面（n+1）个0；而计算下标的方法是hash.&（lenth-1），所以oldCap-1写成2进制就是n个1而newCap-1写成2进制是n+1个1，他们就是在n+1位不同一个是0一个是1，所以如果hash的第n+1位是0则hash & （oldCap -1）和 hash & （newCap -1）结果相同否则不同 ，而hash & oldCap正好能得到hash的第n+1位是1还是0，例如 ：oldCap如果是8，newCap就是16写成2进制 oldCap ：1000 newCap：10000，oldCap-1 ：111 ，newCap - 1:1111，这时候就是 hash & 0111 和 hash & 1111，如果hash的二进制第四位是0则 hash & 0111 和 hash & 1111是一样的，如果是1则不一样，而hash & oldCap 正好 能获取到hash的第四位是0还是1.

分成两个链表之后下面有一句newTab[j + oldCap] = hiHead;直接把下标计算出来了，因为如果像上面说的hash的最高位是1那   hash &（oldCap-1） 和 hash & （newCap -1）就差 那个 oldCap

6.为什么把头插法改成尾插法（具体实现看看源码）

由于 JDK 1.8 转移数据操作（扩容时） = 按旧链表的正序遍历链表、在新链表的尾部依次插入，所以不会出现链表 逆序、倒置的情况，故不容易出现环形链表的情况 ，但jdk1.8仍是线程不安全的，因为没有加同步锁保护。

链表头插法的会颠倒原来一个散列桶里面链表的顺序。在并发的时候原来的顺序被另外一个线程a颠倒了，而被挂起线程b恢复后拿扩容前的节点和顺序继续完成第一次循环后，又遵循a线程扩容后的链表顺序重新排列链表中的顺序，最终形成了环。

因为1.7头插法扩容时，头插法会使链表发生反转，多线程环境下会产生环。

hashMap的hash算法不是直接取模,效果和取模一样：

hash = (h = key.hashCode()) ^ (h >>> 16) 
tab[i = (n - 1) & hash])

hashMap发生hash碰撞之后链表转指针(树化)的条件不只是链表长度大于8:

static final int MIN_TREEIFY_CAPACITY = 64;  
static final int TREEIFY_THRESHOLD = 8;
    if (binCount >= TREEIFY_THRESHOLD - 1)
                    treeifyBin(tab, hash);

    final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        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);
        }
    }

可以看到当hashMap的散列总长度小于64的时候会先扩容，所以树化的条件是散列长度大于等于64并且链表长度大于8大于等于9的时候

			// 遍历链表，只在两种情况下才会跳出循环
			 for (int binCount = 0; ; ++binCount) {
            
            	//第一种：已经遍历到尾部,在最后插入新节点跳出，因节点数量+1 判断是否需要树化
                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指向的节点与要插入节点的key相同，此次put为覆盖操作
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等，跳出循环
                    break;


                // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
                p = e;
            }

问题是源码 明明是 if (binCount >= TREEIFY_THRESHOLD - 1) TREEIFY_THRESHOLD 是8，那应该是 binCount >= 7为啥说是 大于8

遍历过程中p从第一个节点遍历到最后一个节点
但由于binCount是从0开始计数，所以在做树化判断时binCount的值等于 链表长度 - 1（注意此时的链表长度没有算新插入的节点）
判断条件为 binCount >= TREEIFY_THRESHOLD - 1 => binCount+1(链表长度) >= TREEIFY_THRESHOLD

但此时链表新插入了一个节点p.next = newNode(hash, key, value, null);

所以链表树化的那一刻，它的真实长度应该时binCount+1+1 => 链表长度>TREEIFY_THRESHOLD(8)

即：

链表长度大于8时，treeifyBin()方法被调用
（在做树化判断时，链表长度 = binCount+1（从零计数）+1（新插入节点） = bincount +2）
（判断条件： (bincount >= 8-1) => (bincount>=7) => (bincount+2>=9) => (链表长度>=9) 长度是整数 大于等于9也就是大于8）

为什么在JDK1.8中进行对HashMap优化的时候，把链表转化为红黑树的阈值是8,而不是7或者5呢？

根据注释中写到，理想情况下，在随机哈希码和默认大小调整阈值为 0.75 的情况下,存储桶中元素个数出现的频率遵循泊松分布,平均参数为 0.5，有关 k 值下,随机事件出现频率的计算公式为 (exp(-0.5) * pow(0.5, k) /factorial(k))）大体得到一个数值是8，那么退化树阀值为什么是6？如果退化树阀值也是8，则会陷入树化和退化的死循环中。如果退化阀值是7，假如对hash进行频繁的增删操作，同样会进入死循环中。如果退化树阀值小于5，我们知道红黑树在低元素查询效率并不比链表高，而且红黑树会存储很多索引，占有内存。所以退化阀值设为6比较合理。

JDK1.7是先扩容再插入，而JDK1.8是先插入再扩容。为什么？

注意1.7的扩容条件是 size >= threshold && (null != table[bucketIndex]) 是大于门阈值和插入的时候hash数组的 那个位置不等于空

　　　这个问题网上查找很多资料没有明确答案。可能原因是JDK1.7采用头插法，扩容后，计算hash，只需要插入链表头部就行。而JDK1.8采用尾插法，如果先扩容，扩容后需要遍历一遍，再找到尾部进行插入。

jdk1.7和1.8中hashmap有什么不同

1.jdk1.7是数组+链表的结构，jdk1.8中是数组+链表+红黑树的结构
2.jdk1.7链表中数据插入的方式是头插法，插入元素要放到桶中，原来元素作为插入元素的后继元素。而jdk1.8采用的是尾插法，直接放到链表尾部。
3.jdk1.7在扩容的时需要对元素进行重新哈希以确定元素在新数组中的位置，而jdk1.8中不需要重新哈希，要么存储在和原数组相同的位置，要么存储在原数组位置+原数组长度的位置。
4.jdk1.7中是先判断是否需要扩容，再插入，而jdk1.8是先插入，在扩容