扒光 HashMap

阅读要求：具备一定的数据结构基础知识，例如：数组，链表，二叉树的数据结构以及特性

HashMap 的构成

数组 + 链表 + 红黑树

    transient Node[] table;

默认容量：

    /**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

扩容阀值

    int threshold;

加载因子：默认是 0.75，范围：0-1

    final float loadFactor;

HashMap 数据结构原型图

图片来源于：一文读懂HashMap
一个数据，是如何保存到数据的哪一个下标下呢？

index = (size - 1) & hash

哈希碰撞（哈希冲突）

哈希碰撞的定义：

不同的 key 值，通过哈希函数，计算出来的 hash 相同

举个栗子：

哈希函数为： hash = key % 3
传递的 key 分别为：1 和 4，于是有： hash(1) = 1%3 = 1； hash(4) = 4%3 =1;
不同的 key, 计算出来的 hash 值相同，故产生了哈希碰撞

哈希函数

良好的哈希函数应尽可能的具备有以下几种特性：

计算速度快
计算出来的结果离散，哈希碰撞的机会尽可能少

解决哈希碰撞的方法

链地址法：将 hash 相同的，存储在同一线性链表中（参考：上方数据结构原型图）。
其他方法：探针法，开放地址法，再哈希法等

HashMap 的扩容机制

扩容机制

扩容时机

size >= loadFactor * capacity

举个栗子：loadFactor 为 0.75， capacity 为 16, 则触发扩容的时机就是 12 时触发。

扩容机制：容量翻倍

threshold = oldThr << 1

扩容的时机

扩容优化：

为了避免频繁的扩容，造成性能问题和内存浪费，在确定容量的情况下，应使用 HashMap 两个参数的构造函数，指定容量以及扩容因子

    public HashMap(int initialCapacity, float loadFactor) {

    }

默认的扩容因子为什么是 0.75？

利用统计学的泊松分布概念计算得出，可参考文章 HashMap的loadFactor为什么是0.75？

HashMap 的存储过程

存储过程流程图

源码解析

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node[] tab; Node p; int n, i;
      // 获取初始化数据
        if ((tab = table) == null || (n = tab.length) == 0)
           // 数据进行初始化，并且给会重新计算 threshold 大小为 0.75 * 容量
            n = (tab = resize()).length;
       // 计算得到要插入到数据的哪一个位置
        if ((p = tab[i = (n - 1) & hash]) == null)
            // 如果当前数组位置为空，则直接将此节点插入
            tab[i] = newNode(hash, key, value, null);
        else {
            // 代表数组位置不空，则：1. 相同 key 值则替换位置下的值 2. 如果是红黑树，则插入到红黑树中；如果不是红黑树，则插入到链表中
            Node e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //  找到相同 key 值
                e = p;
            else if (p instanceof TreeNode)
              // 红黑树，则插入到红黑树中
                e = ((TreeNode)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
                          // 链表数量达到 8 个，链表转红黑树
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        // 找到相同 key 值
                        break;
                    // 当前链表，指向下一个
                    p = e;
                }
            }
            // 代表找到相同的 key 值，将此节点中的值替换
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        // 当前容量 +1，满足扩容条件，进行扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

其它键值存储方式

HashMap 和 Hashtable 的区别

HashMap 是线程不安全的， HashTable 是线程安全的，因为 Hashtable 提供的函数都加载了 synchronize 关键字，故 Hashtable 的效率低；
HashMap 默认容量是 16，Hashtable 的默认容量是 11；
存储结构不同等。

HashMap 的其他替代方案

SparseArray
Hashtable
ConcurrentHashMap

不吐不快

threshold 在构造函数的时，是代表容量值，在首次 putVal 中，对 table 进行初始化，重新将 threshold 的值变为 capacity * loadFactor，threshold 存在二异性，巨坑
resize 函数逻辑写得渣到掉土了

参考文献

一文读懂HashMap

HashMap的loadFactor为什么是0.75？