互联网架构-Java8集合框架源码分析-046：Jdk1.8HashMapPut方法源码分析

1 HashMap8基本实现原理分析

课程内容：
1.Jdk1.8与1.7HashMap到底有那些区别？
2.Jdk1.8比1.7HashMap优化了那些地方
3.完全百分百高仿HashMap集合框架

Java8为什么使用数组+链表+红黑树实现？
如果index冲突过多，可能导致单个链表长度过长，查询效率非常慢，时间复杂度为o(n)，java8链表长度>=8的情况下，开始转换红黑树存放，时间复杂度o(log n)。

2 HashMap8优化了7那些bug

Java8对java7 hashMap多了哪些改进？

1. 数据结构
   Jdk7hashMap 使用数组+链表
   Jdk8hashMap 使用数组+链表+红黑树
2. 扩容bug
   Jdk7扩容在多线程情况下，可能会存在死循环问题，采用头插入法；
   Jdk8扩容在多线程情况下，采用尾插法，已经解决扩容死循环问题。

3 HashMap8的Put方法实现（除红黑树）

public interface MayiktMap<K, V> {
    V put(K key, V value);
}

public class MayiktHashMap<K, V> implements MayiktMap<K, V> {

    /**
     * 默认的加载因子0.75
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 阈值
     */
    final float loadFactor;

    public MayiktHashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
    }

    /**
     * hashMap中存放的所有链表
     */
    transient Node<K, V>[] table;
    /**
     * 转红黑树阈值
     */
    static final int TREEIFY_THRESHOLD = 8;
    /**
     * 加载因子大小
     */
    int threshold;

    /**
     * 最大的容量
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;
    /**
     * 默认的数组容量16
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

    public V put(K key, V value) {
        // onlyIfAbsent 如果为真，不改变现有值，false表示可以覆盖
        return putVal(hash(key), key, value, false, true);
    }

    private V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        // tab,数组中存放的所有链表
        Node<K, V>[] tab;
        // p,链表中的某一个节点 根据key计算数组index位置的链表的首个节点
        Node<K, V> p;
        // n,当前数组长度；i,当前key计算hash值存放的数组index位置
        int n, i;
        // table中数组为空，开始扩容
        if ((tab = table) == null || (n = table.length) == 0) {
            n = (tab = resize()).length;
        }
        // 如果从数组中没有获取到对应的链表，开始赋值
        if ((p = tab[i = (n - 1) & hash]) == null) {
            // 局部变量tab赋值，全局变量table也会有值，相同的引用地址
            tab[i] = newNode(hash, key, value, null);
        } else {
            // 当前的key产生index冲突
            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) {
//                // 判断当前node是否是红黑树节点，若是，以红黑树规则进行存放
//                e = p;
//            }
            else {
                // 不是以红黑树形式存放
                for (int binCount = 0; ; ++binCount) {
                    // 没有下一个节点，p为链表尾节点
                    if ((e = p.next) == null) {
                        // hash值相同，key内容不同
                        // 新节点放在老节点后面，尾插法
                        p.next = newNode(hash, key, value, null);
                        // binCount从0开始
                        if (binCount >= TREEIFY_THRESHOLD - 1) {
                            treeifyBin(tab, hash);
                        }
                        break;
                    }
                    // 遍历链表出现hash值相同，值也相同情况，新值（节点）替换旧值（节点）
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
                        break;
                    }
                    // 指针移动
                    p = e;
                }
            }
            if (e != null) {
                V oldValue = e.value;
                // 如果原来值为空
                if (!onlyIfAbsent || oldValue == null) {
                    e.value = value;
                    return oldValue;
                }
            }
        }
        return null;
    }

    /**
     * 链表转红黑树存放
     *
     * @param tab
     * @param hash
     */
    private void treeifyBin(Node<K, V>[] tab, int hash) {
    }

    /**
     * 创建Node节点
     *
     * @param hash
     * @param key
     * @param value
     * @param next
     * @return
     */
    private Node<K, V> newNode(int hash, K key, V value, Node next) {
        return new Node(hash, key, value, next);
    }

    /**
     * 扩容数组
     *
     * @return
     */
    private 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) {
                // 加载因子阈值为Integer最大值
                threshold = Integer.MAX_VALUE;
                return oldTab;
            } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) {
                // 数组容量和加载因子阈值都扩大一倍
                newThr = oldThr << 1; // double
            }
        } else if (oldThr > 0) {
            // 新的容量为原加载因子阈值(这里理解不了...)
            newCap = oldThr;
        } else {
            // 第一次初始化数组
            newCap = DEFAULT_INITIAL_CAPACITY; // 16
            newThr = (int) DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY; //16*0.75=12
        }
        // 如果新的加载因子值为0
        if (newThr == 0) {
            // ft = 新容量*0.75
            float ft = (float) newCap * loadFactor;
            newThr = (ft < (float) MAXIMUM_CAPACITY) ? (int) ft : Integer.MAX_VALUE;
        }
        // 更新加载因子阈值全局变量
        threshold = newThr;
        // 用新容量创建新数组
        Node<K, V>[] newTab = new Node[newCap];
        // 更新table全局变量，注意table和newTable引用地址相同，newTable
        table = newTab;
        return newTab;

    }

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

    // 链表节点
    static class Node<K, V> {
        final int hash;
        final K key;
        V value;
        Node<K, V> next; //下一个节点

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

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        @Override
        public final String toString() {
            return key + "=" + value;
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

    }

    public void tableTest() {
        Node[] oldTab = null;
        // 创建容量为16的新table
        Node[] newTab = new Node[16];
        // 新table赋值给旧table
        oldTab = newTab;
        // 新table首节点赋值
        newTab[0] = new Node(0, 0, 0, null);
        // oldTab和newTab指向同一个引用地址
        System.out.println(oldTab[0].value); // 0
    }
}

4 HashMap8的Put方法源码断点调试

public class Test002 {
    public static void main(String[] args) {
        //断点调试hash冲突
        MayiktHashMap<Object, Object> objectObjectMayiktHashMap = new MayiktHashMap<Object, Object>();
        objectObjectMayiktHashMap.put("a", "mayikt_a");
        objectObjectMayiktHashMap.put(97, "mayikt_97");
        objectObjectMayiktHashMap.put("a", "mayikt_666");
    }
}