HashMap底层实现原理

容器

容器分类

容器分为Collection和Map。Collection又分为List、Set、Queue。
注意：掌握HashMap，LinkedList，ArryList，Vector，HashSet，HashMap。

容器发展史

• 总结
  • 一开始是有两种，HashTable，Vector
  • HashTable是HashMap的前身，Vector是List的前身
  • HashTable和Vector作为一代的容器，容器中几乎所有的方法都是加上了sync方法的
  • 初代的Sync的效率非常低，提供了HashMap和List不带锁的两种方法
  • 但是完全没有锁也不好，于是提供了将HashMap转换为线程安全的容器
  • SynchronizedMap和HashTable最大的区别就在于SynchronizedMap的锁更加细化，我们可以看到，SynchronizedMap的里面添加了一个mutex对象，这个对象用于作为锁，每一次上锁的时候不需要将整个方法给锁上，只需要锁上mutex对象即可（源码如下）

Map syncMap= Collections.synchronizedMap(new HashMap<>());
//源码
private static class SynchronizedMap<K,V>
        implements Map<K,V>, Serializable {
        private static final long serialVersionUID = 1978198479659022715L;

        private final Map<K,V> m;     // Backing Map
        final Object      mutex;        // Object on which to synchronize

        SynchronizedMap(Map<K,V> m) {
            this.m = Objects.requireNonNull(m);
            mutex = this;
        }

HashMap底层原理

初始化

HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();

看见new，知道在堆内存里面开辟一块空间
构造函数：

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

初始化了一个负载因子，

 static final float DEFAULT_LOAD_FACTOR = 0.75f;

负载因子默认为0.75f

transient Node<K,V>[] table;

数组里原对象是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;
        }

一些属性，一个key，一个value，用来保存我们往Map里放入的数据，next用来标记Node节点的下一个元素。
HashMap我们就初始化好了，成员变量table数组默认为null，size默认为0，负载因子为0.75f，初始化完成。

put

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

调用了putVal方法

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))))
                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) {
                        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;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

具体分析：

if ((tab = table) == null || (n = tab.length) == 0)
    n = (tab = resize()).length;

当放入第一个元素时，table为空，触发resize方法，以下是其关键代码

newCap = DEFAULT_INITIAL_CAPACITY;
//而DEFAULT_INITIAL_CAPACITY定义是如下
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

移位运算符，1 << 4 其实就是相当于16。当我们放入第一个元素时，如果底层数组还是null，系统会初始化一个长度为16的Node数组。而我们 newThr就是阈值，这里初始为16*0.75=12，意思是我们不用等到16才扩容，在达到阈值12时，就可以提醒或者准备扩容。

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

• hash值是传过来的，其中n是底层数组的长度，用&运算符计算出i的值
• p = tab[i];//用计算出来的i的值作为下标从数组中元素
• if(p == null){//如果这个元素为null，用key,value构造一个Node对象放入数组下标为i的位置

这里就比较有意思，(n-1)的值&上hash值，初始时，我们的n为8，(n-1)换成二进制就是111，而我们&操作只有同时为1才为1。所以说我们不管hash值到底有多长，我们只关心其最低的三位的值，这样就得到0-7的下标。万一计算出来的下标值i重了怎么办？我们来看一看HashMap是怎么解决冲突的。

HashMap解决冲突

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

以上就是解决hash冲突
p.next = newNode(hash, key, value, null);
也就是说new一个新的Node对象并把当前Node的next引用指向该对象，也就是说原来该位置上只有一个元素对象，现在转成了单向链表。

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
       treeifyBin(tab, hash);//把链表转化为红黑树
 break;
 //而TREEIFY_THRESHOLD的值是
 static final int TREEIFY_THRESHOLD = 8;

当链表长度到8时，将链表转化为红黑树来处理，
而当我们的长度为6，就退化成链表。
static final int UNTREEIFY_THRESHOLD = 6;

put总结

在hashMap中放入（put）元素，有以下重要步骤：

1、计算key的hash值，算出元素在底层数组中的下标位置。

2、通过下标位置定位到底层数组里的元素（也有可能是链表也有可能是树）。

3、取到元素，判断放入元素的key是否==或equals当前位置的key，成立则替换value值，返回旧值。

4、如果是树，循环树中的节点，判断放入元素的key是否==或equals节点的key，成立则替换树里的value，并返回旧值，不成立就添加到树里。

5、否则就顺着元素的链表结构循环节点，判断放入元素的key是否==或equals节点的key，成立则替换链表里value，并返回旧值，找不到就添加到链表的最后。

精简一下，判断放入HashMap中的元素要不要替换当前节点的元素，key满足以下两个条件即可替换：

1、hash值相等。

2、==或equals的结果为true。

HashMap总结

• HashMap的最底层是数组来实现的，数组里的元素可能为null，也有可能是单个对象，还有可能是单向链表或是红黑树。
• 文中的resize在底层数组为null的时候会初始化一个数组，不为null的情况下会去扩容底层数组，并会重排底层数组里的元素。
• HashMap的扩容临界点是超过了当前的容量最大值的 3 / 4
• HashMap的扩容策略是直接将原本的容量和临界点左移1位，也就是直接扩大为原来的2倍，如果达到了INTEGER.MAX_VALUE，那么就不会再扩大容量，而是将临界点扩大到INTEGER.MAX_VALUE
• size中最重要的点就是如何将原来的数据移植到新的Node[ ]，如果没有hash碰撞的话，那么解决方法就是直接rehash一下，rehash的值就作为新的index。 newTab[e.hash & (newCap - 1)] = e;
• 如果有哈希碰撞的话，那么首先判断是不是红黑树结构
• 当链表长度到8时，将链表转化为红黑树来处理，
  而当我们的长度为6，就退化成链表。