【Java基础】HashMap解析

一、 哈希函数理解

如果我们自己要设计一个数据结构，首要任务是查询快，其次增删改快，怎么设计呢？

我们知道，数据结构的物理存储结构只有两种：顺序存储结构和链式存储结构（像栈，队列，树，图等是从逻辑结构去抽象的，映射到内存中，也这两种物理组织形式），所以我们要自己设计一个容器装数据，也得从这两个结构下手：

1. 顺序存储，这个代表的对象就是数组，内存直接分配一块连续的空间，在此基础上，只要你知道相对于数组第一个位置的下标，就能快速访问到想要的数据，非常快（例如：a[3]=5；），时间复杂度O（1），但是给定一个值让你找，那也只能遍历了，时间复杂度是O（n）。数组还有有个弱点，就是当你要在已有数据中间新增或者删除的时候，都会导致后续的元素平移，耗时，这不符合我们的预期。
2. 链式存储结构，其内存散碎在各处，每个元素通过存储自己前后邻居的位置，而你只知道住在第一家的位置，你想找任何一个人，唯一的方法就是一个一个问，这样查询的效率极低，时间复杂度是O（n），优势是你想插队或者删除一个，只要通知它左右邻居就可以，很方便。

因为我们首要任务是查询快，而顺序结构特点就是查询快，只要你能知道它的位置就能直接访问它的元素，所以主体我们选择顺序结构，但是实际工作中，我们都是直接按值查找，那不是没快么，如果有个算法，能根据值算出元素在数组中的位置就好了，这个算法其实就是哈希算法。

哈希算法：这个算法通俗来说就是把你要查找的内容翻译成位置。比如我们要新增或查找某个元素，我们通过把当前元素的关键字 通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作。这个函数可以简单描述为：存储位置 = f(关键字) ，这个函数f一般称为哈希函数，这个函数的设计好坏会直接影响到哈希表的优劣。

整个过程有点像推币机：

只不过中间算法部分，被替换成了哈希算法，它会根据小球“key”的哈希，决定你在数组的哪个槽里。（如果按照当前算法，最后小球的落点是符合正态分布的），好的哈希算法，会精良把小球分散开来，不让他们落入同一个槽里，如果不幸落入同一个槽，那这就是哈希碰撞，也叫哈希冲突。

有了碰撞怎么处理呢，毕竟不能让一堆数据放到同一个地址里，处理哈希碰撞的方法有：
开放地址法：发生冲突，继续寻找下一块未被占用的存储地址。
再散列函数法：发生冲突就换一个散列函数，总有一个不碰撞的。
公共溢出区法：即为所有冲突的关键字建立一个公共的溢出区来存放，在查找时，对给定值通过散列函数计算出散列地址后，先与基本表的相应位置进行比对，如果相等，则查找成功，如果不相等，则到溢出表去进行顺序查找。
链地址法：把后续算出来同一个地址的小球（元素）用链表串起来，为什么用链表呢，因为方便增减，但是我们前面说过了，链表只能遍历查，所以要求这个链子不能太长，最多7个（jkd1.8），再长就转成红黑树。这个就是HashMap采用的方法。

二、 HashMap解析

1. 构造函数

HashMap的在new的时候，并不会初始化它内部的Node对象数组，只会设置数组的容量和扩容阈值（扩容阈值是指一旦HashMap装满到一定程度，会触发自动扩容，一般扩容成当前容量的两倍）。

HashMap有以下4个构造函数

//负载系数
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//1 不带任何参数的，就是日常最多用到的，它只设置了一下阈值负载系数，也就是最大容量的75%
public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//2 传入初始化容量的，阈值负载系数还是用默认的
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

//3 传入初始化容量和阈值负载系数
public HashMap(int initialCapacity, float loadFactor) {
		//如果传入的容量大于最大容量了，就默认使用最大容量。
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        this.loadFactor = loadFactor;
        //下次表容量到达threshold值时，触发扩容。
        this.threshold = tableSizeFor(initialCapacity);
}

//4 根据传入的Map来构造一个新的HashMap，老Map中的值会赋给新的HashMap中。
public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
}

tableSizeFor方法，这个方法单独列出来讲，是因为涉及到后续我之前没有理解的点，那就是这个类中的threshold到底是什么。

官方给的doc直译是：返回给定目标容量的两个大小的幂。

实际测试的是返回一个比给定值大的最小的二的次幂，比如你传5或者6、7，它就返回8，你传9、10、11、12、13、14、15，它就返回16。

在我实际的测试中，如果你初始化的时候，给定的容量不是2的整次幂，那么你新表的容量，就是从这个函数中来的，后续扩容的地方会详细讲为什么，这里直接说结论，如果你初始化容量是2的整次幂，那么threshold就是扩容阈值，如果不是，则是表容量。

    
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

2. put方法

如果你第一次使用put，那就初始化数组并存值，如果之前初始化过，则正常存值。

也可以理解成往HashMap里放小球，一个小球对于HaspMap来说就是一个Node对象，Node对象就是我们使用的key-value格式。

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
		
		//这里可以看出，Node除了能存储Key-Vaule以外，还能组成一个单向的链表。
        Node(int hash, K key, V value, Node<K,V> next) {
			...
        }
        ...
    }

put方法源码：

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

参数解析：
hash:key值算出来的hash值，这个就是我们上面说的，算位置。
key:这个就是存入数据的Key。
value:存入数据的value。
onlyIfAbsent：如果为true，则不更改现有值。（不知道干啥的）
evict：如果为false，则表处于创建模式。（不知道干啥的）

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //判断当前map中的Node数组是不是空的，如果是空的，调用resize()方法，这个方法的作用是将Node数组大小初始化或加倍，这里用到的就是初始化。无论是不是第一次初始化，都要把最终数组也就是tab的长度赋值给n。
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // (n - 1) & hash 这就是计算位置的算法，找到新存入Node的key的hash值，与数组长度-1相与，然后判断这个位置是否有值了。
        if ((p = tab[i = (n - 1) & hash]) == null)
        	//如果没有值，说明这个位置是空的，那直接new一个Node放到这个位置上。
            tab[i] = newNode(hash, key, value, null);
        else {
        	//如果不为空，说明碰撞了，在if中已经把这个位置已经存在的原有元素取出来，赋值给p，记住这个p是原来就有的节点啊。
            Node<K,V> e; K k;
            //判断p是不是就是新存入的这个元素，也就是同一个key，如果是的话就直接覆盖。
            if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
            	//如果不是，则判断p是不是一棵树的节点，如果是的话，那就走新增树节点的逻辑，把新加入的拼到红黑树上。
                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);
                        //TREEIFY_THRESHOLD是8，这里就是上文所说的，如果链表太长，会影响后续查询效率，只要大于等于8，就把链表转成红黑树。
                        //这里有个迷惑人的点，TREEIFY_THRESHOLD - 1不是等于7么，为什么是大于8呢，因为这里的binCount是从0开始的，是元素开始遍历的位置，不是数组长度，数组长度应该是binCount+1，所以这个判断应该是binCount+1 >= TREEIFY_THRESHOLD。
                        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;
                //这一步在HashMap没有实现，是为了LinkHashMap用的，为的是使用LRU算法。
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //如果没有碰撞，数据存入Node数组中了，那把数组size加一，然后跟阈值相比，HashMap默认阈值是最大size的四分之三，如果超了，触发扩容机制。
        if (++size > threshold)
            resize();
        //这一步在HashMap没有实现，是为了LinkHashMap用的，为的是使用LRU算法。
        afterNodeInsertion(evict);
        return null;
    }

扩容resize()：将Node对象数组的大小初始化或加倍。如果数组为空，则根据字段阈值中保留的初始容量目初始化数组。否则，使用二的整数次幂扩容（一般都是现有基础的两倍），每个桶中的元素必须保持在相同的索引中，或者在新数组中以二次幂偏移量移动。

   //扩容逻辑太长了，这里为了方便使用简化版本
   final Node<K,V>[] resize() {
   		//现有表
        Node<K,V>[] oldTab = table;
        //现有表容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //threshold：触发扩容的阈值
        int oldThr = threshold;
        //newCap新表的容量，newThr新表的阈值
        int newCap, newThr = 0;
        //a1.先判断老表是否有值，如果有，则容量和阈值都2倍扩容（oldCap << 1的意思是，原有值向左边移动一位，因为是二进制，所以左移一位就是乘以2，比如十进制左移两位就是，23<<2 = 2300）
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
            //这里判断老表的容量是不是已经是最大的了，如果已经是最大的直接返回原表。
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //a2.这种情况就是new的时候，给定的初始化容量不是2的整次幂，则oldThr就会自动算出大于你规定的容量最近的2的整次幂，然后作为新表容量。
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        //a3.这种情况就是上面说的第一次调用put的情况，都按照默认值初始化新表
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
		//a2那种情况下，给新表计算一个新的阈值
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        //到这一步，threshold算是回归他的老本行了，扩容阈值
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        //根据新容量构件一个新的表（Node对象数组）
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        //这里判断老表是否为空，如果不为空则迁移老表数据到新表
        if (oldTab != null) {
        	//遍历老表，往新表里塞数据
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)//如果它就是新表这个位置的第一个，那就直接放
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)//如果是树，放到树的节点里去
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // 如果是链表，走链表的迁移
                        ...
                    }
                }
            }
        }
        return newTab;
    }

3. get方法

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

//通过key值和key值的hash值获取对应元素
final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        //这里要确定查询的表不为空，并且hash值对应的位置不能为空
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //第一个节点很重要，决定了这个元素的所在桶（所谓的桶，就是Node数组的一个元素位置，这个位置可能就是一个元素存在那，也肯能是链表或者红黑树）的数据存储结构。
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                //第一个元素就是要找的，直接返回
                return first;
            if ((e = first.next) != null) {
            	//第一个元素不是要找的元素，那就看看是树还是链表，然后调用对应的查找方法。
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

4. remove方法

    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        //顺序基本和查找一样，先确定表不是空的，然后找到表中对应的位置，再通过判断第一个节点来摸清楚桶的数据结构
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> node = null, e; K k; V v;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            //这里就是根据不同数据结构，移除对应的元素
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                else if (node == p)
                    tab[index] = node.next;
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }