首先一个节点进来做 Hash 值并取余运算，hash到对应的桶，开有没有hash冲突，如果没有直接插入，如果有就需要遍历 链表 ，看有没有key相同的情况，如果有就进行值的替换，如果没有就插到链表尾部（哪些判断是否变为 红黑树 逻辑在下面进行解析，这里做个大概描述）

1.7使用头插法，因为他认为先最近插入的最容易被访问，但是在并发，扩容数组的时候可能会出现死循环。因为并发扩容reHash一张新的表。扩容的时候会出现两个数组。使用头插法，且插入时不是原子性的，因此可能会出现死循环。

因此1.8又变为了尾插法

初始容量为16，只不过是懒加载

  static  final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
复制代码  

使用内部类Node数组

 static class Node<K,V> implements Map.Entry<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;
        }
复制代码  

Node数组组成的Hash表

 transient Node<K,V>[] table;
复制代码  

1，加入时先判断数组table是否为空，因为是懒加载第一次肯定为空，那么就进行初始化，扩容，并把table赋值给tab

 if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;//resize()扩容
复制代码  

2，使用&代替 取模运算 ，确认桶的位置

 n % 2^n = n& (2^n-1)
复制代码  

3，对hash值取模，确定要hash到tab/table的哪个桶，如果桶为空的话，表示没有hash冲突，就把当前Put()的Node对象，放入该桶内。

 if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
复制代码  

4，如果产生hash冲突，我们可以假设此时链表又几个元素了，先判断和首节点是否相同，因为他们认为首节点是最容易被访问的。判断键是否相同，如果键相同就把Value值进行覆盖

判断key是否相同：先判断二者hash值是否相同，hash值相同Key也不一定相同，然后还需要比较key的地址值，但是key可能使对象，如果 程序员 想让两个对象相同就会重写equals方法，相当于人为想让他们相同，只要这两者有一个成立就行了，但前提是hash值是相同的。

 Node<K,V> e; K k;
 if  (p. hash  == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
复制代码  

5，key相同则直接走线面的步骤，进行Value值的替换。

 if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
复制代码  

6，产生Hash冲突，且和首节点不相同，那么我们需要遍历这个链表，但是在遍历链表之前需要先判断是不是已经是红黑树了，如果是就向红黑树中PUT节点

 else if (p  instanceof  TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
复制代码  

7，产生Hash冲突，且和首节点不相同，且链表没有树化，那么我们需要遍历这个链表，判断键是否相同，如果键没有匹配的，就插入到链表尾部，插入后，判断长度是否超过8，超过就进行树化(里面还会对数组长度进行判断，如果没有超过64，就进行扩容)

 for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //插入后，判断长度是否超过8，超过就进行树化
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
复制代码  

8，产生Hash冲突，且和首节点不相同，且链表没有树化，那么我们需要遍历这个链表，判断键是否相同，如果找到了匹配的键，就退出死循环，会自动执行最后面的，Key相同把Value值进行替换的代码

 else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //如果找到了匹配的键，就退出死循环
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
复制代码