JDK1.7和JDK1.8中的HashMap源码比较

（1）执行put（K key,V value）操作时的比较：

JDK1.7中的源码如下

public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            //如果key为null值，那么执行putforNullKey（Value）操作
            return putForNullKey(value);
        int hash = hash(key);
        //对key求对应的hash
        int i = indexFor(hash, table.length);
        //根据上面求的的hash值去确定插入的key在table数组的位置
        //这里使用的是hash&(length-1)得到对应的下标的
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                /*如果在相同的table[i]中已经存在entry的hash值跟你要插入的key值的hashcode相同
                并且（这个entry的key的引用地址（因为hashmap中存的都是包装类型，所以==比较的           
                是地址）和key的相同（说明是同一个对象）或者key的数值相同（说明是同一个对   
                */
                //如果key在hashmap中已经存在，那么用新的value取代旧的value             
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                /*在HashMap中，在执行put方法时如果当前的key值已经存在，则在其value值被重写时就
                会调用这个方法*/        
                return oldValue;
                //使用return结束当前方法
            }
        }
        //HashMap中不存在当前的key值时，才会调用如下的addEntry()创建一个新的entry实体对象，头
        //插法加入到table[i]
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

下面是JDK1.7中当插入的key值是null时执行的操作： 

默认插到table[0]的位置，首先遍历table[0]下的所有entry,如果原来已经有一个key值为null的entry存在，将原来的value值替换为当前要插入的value的value,结束方法。原来不存在key为null的时候，执行addEntry（）方法，在table[0]处头插法，新创建一个entry实体，key值为null。

  private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
                //如果为null的key已经存在的话，将原来的value值替换为当前要插入的value的value    
        }
        modCount++;
        addEntry(0, null, value, 0);
        //如果没有找到为null的key值，在创建一个entry并头插到table[0]
        return null;
    }

 而JDK1.8中的HashMap的put（）由于加入了红黑树的存储方式，以及在计算数组下标识时发生了一些变化。

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

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
            //如果要插入的数组位置没有元素的话，直接新增一个节点
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //如果要插入的key的hash和当前遍历到的hash相同，并且（引用地址相同或者数值相同）
                //说明是同一个对象，将p赋值给node e
                e = p;
            else if (p instanceof TreeNode)
                //如果数组下标下是一个红黑树的话
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {//否则的话遍历该数组中的node
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {//没找到相同的key,新建一个node，尾插法插入
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                            //插入新节点后，链表长度大于8，转换为红黑树存储
                        break;
                    }
                    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)
                    //传过来的onlyIfAbsent是false，加个非，所以是true.
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
                //如果原来就存在了当前要put的key值，则替换掉原来的value。
            }
        }
        ++modCount;
        if (++size > threshold)
            //当前插入的key值原来没有的话，判断size+1是否大于阈值，大于的话扩容。
            //相当于提前判断了，这样保证了上面的新key插入成功。
            resize();
        afterNodeInsertion(evict);
        return null;
    }

总结：

（1）计算key的hash值的方式不同，但都是利用得到的hash值，利用hash&(table.length-1)计算得出应该插入的数组下标i

（2）JDK1.7首先判断key是否为null,如果为null,再判断hashmap中是否已经存在null,有的话用新的value替换旧的，没有的话直接新建一个entry头插到table[0];如果key不为null，那么遍历table[i],如果已经存在key，用新value替换旧value.如果不存在，新建一个entry，头插到table[i]中.

JDK1.8中如果table[i]中没有元素，直接新建一个node.如果存在元素，如果正好第一个元素就跟key相同，将这个元素赋值给一个node e,如果不同的话，遍历数组中的元素，如果元素是个TreeNode类型的节点，执行红黑树存储的操作。如果就是正常的链表的话，就一直遍历，遍历结束也没找到相同key值的，判断数组长度和阈值的关系，看是否需要转换为红黑树存储（首先将单向链表转换为双向的，之后再存储成红黑树的形式）。存在的话停止遍历。

node e 只会在存在相同key时才不为null,此时用新value替换掉旧的value.若不存在相同的key,判断再加入一个元素是否需要扩容。

 注意：在JDK1.8时，只要是加入元素之后达到了阈值，就会转换为红黑树存储，但是删除键值对时，如果小于下限6并不会立刻从红黑树转换为链表。而需要在执行resize()的时候才会判断是否需要转化。