你还在为HashMap的源码苦恼么？

•  在学习HashMap的原理后我们需要掌握以下思考题！

1、HashMap是哈希表结构，JDK8开始由数组、链表、红黑树组成，既然后红黑树是否需要利用comparable指定的排序规则？是否需要传递比较器comparator指定规则？

2、HashMap的效率为什么会更高？

3、在Map集合中如果键重复，不会覆盖put方法？

• 下面是我们走进HashMap的源码世界。

static class Node<K,V> implements Map.Entry<K,V> {
        //链表中的键值对对象
        final int hash;  //通过键计算的hash值
        final K key;   //键
        V value;      //值
        Node<K,V> next;  //记录链表下一个节点的地址值


static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // red-black tree links 父节点地址值
        TreeNode<K,V> left;   //左子节点地址值
        TreeNode<K,V> right;  //右子节点
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;   //红黑树节点


transient Node<K,V>[] table;   //哈希表的数组地址值
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 数组默认的长度 16
static final float DEFAULT_LOAD_FACTOR = 0.75f;   //负载因子决定数组扩容机制
static final int MAXIMUM_CAPACITY = 1 << 30;      //hashmap的数组长度最大30


//添加元素
HashMap<String, Integer> hm = new HashMap<>();
hm.put("E-AA", 1);
hm.put("E-BB", 2);
hm.put("E-CC", 3);

//参数1：键
//参数2：值
//返回值：被覆盖元素的值，如果没有覆盖就返回null
public V put(K key, V value) {
  return putVal(hash(key), key, value, false, true);
}

//利用键求哈希值，再对哈希值进行数学逻辑处理
//我的理解：返回值就是返回键的哈希值
static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

//参数1：键的哈希值
//参数2：键
//参数3：值
//参数4：如果键重复了判断是否保留 true 表示旧的元素保留，false 表示旧的元素覆盖
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //定义一个局部变量，用来记录哈希表中数组的地址值
  			Node<K,V>[] tab;
        //临时的第三方变量，用来记录键值对对象的地址值
  			Node<K,V> p;
        //表示当前数组的长度
  			int n,
        //表示索引  
        int i;

        //把哈希表中的数组的地址值，赋值给局部变量tab
        tab = table;
        
        if (tab == null || (n = tab.length) == 0){
          //1.如果当前是第一次添加数据，底层会创建一个默认长度为16，加载因子0.75的数组
          //2.如果不是第一次添加数据，会看数组中的元素是否达到扩容条件
          //如果没有达到扩容条件，底层不会做任何操作
          //如果达到了扩容条件，底层会把数组扩容为原先的两倍，并把数据全部转移到新的哈希表中
          tab = resize();
          //把当前数组长度赋值给n
          n = tab.length;
        }

        //拿着数组的长度跟键的hash值进行计算，计算出当前键值对对象，在数组中中应存入的位置
        i = (n - 1) & hash;
      	//获取数组中的对应元素的数据
        p = tab[i];
        if (p == null)
            //底层创建一个键值对对象，直接放到数组中
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; 
          	K k;
            //等号的左边：数组中键值对的哈希值
            //等号的右边：当前要添加键值对的哈希值
            //如果键不一样，返回false
            //如果键一样，返回true
            boolean b1 = p.hash == hash;
            if (b1 &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                //判断数组中获取出来的键值对是不是红黑树的节点
                //如果是，则调用方法putTreeVal,把当前的节点按照红黑树的规则添加到树当中。
                //红黑树规则：
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //如果数组中获取出来的键值对不是红黑树节点
                //表示按照链表规则进行挂载
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        //创建一个新的节点，挂在下面形成链表
                        p.next = newNode(hash, key, value, null);
                        //判断当前链表长度是否超过8，如果超过8，就会调用treeifyBin
                        //treeifyBin方法继续判断数组长度是否大于等于64
                        //如果同时满足这两个条件，就会把这个链表转成红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //如果hash值一样，就会调用equals方法比较内部的属性值是否相同
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //如果e为null，表示当前不需要覆盖任何元素
            //如果e不为null，表示当前的键是一样的，值会被覆盖
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    //当前要添加的值赋值给要覆盖的值
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //++modCount;
        //threshold: 记录的就是数组的长度 * 0.75，哈希表的扩容时机
        if (++size > threshold)
            resize();
        //afterNodeInsertion(evict);
        //表示当前没有覆盖元素，返回null
        return null;
    }

HashMap的主要思想：

hashmap是由键的哈希值、键、值、如果键重复是否保留值四个参数组成。第一次添加时底层默认创建长度为16，加载因子0.75的数组。当达到数组长度 * 0.75时数组会发生扩容。当数组长度大于等于64时链表转换成红黑树。

总结：（面试中的回答）

hashmap是用来解决hash冲突的动态哈希表。在JDK7采用数组+链表，初次添加元素时默认创建长度16，加载因子0.75的数组。数组长度大于数组长度*0.75时发生扩容。JDK8后当数组长度超过64数组转换成红黑树。hashmap采用put方法添加元素，根据key的hashcode求出hash值得到数组的下标索引，判断索引是否为空，如果为空就直接添加，不为空就继续添加下一个元素。通过for循环判断hash值冲突就比对key是否相等，如果相等返回value。hashmap出现多线程扩容引起死循环、put元素时容易造成元素丢失说明hashmap是线程不安全的。

思想：

代码的逻辑具有两面性，如果我们只知道A面，而且代码中有变量可以控制两面，那么该逻辑一定具有B面。