HashMap 基本原理以及底层源码分析

HashMap 基本原理以及底层源码分析

1.HashMap 的存储结构：

HashMap 是由数组加上链式结构（链表）以及红黑树组成。在 JDK 1.8 增加实现了红黑树的结构。（根据存储数据量的大小会动态的变化存储结构）。

源码实现：

    /**
     * 基本哈希箱节点，用于大多数条目。 （有
     * 关TreeNode子类的信息，请参见下文；有关EntryEntry子类的信息，请参见LinkedHashMap。）
     * Node: 数据节点
     */
    static class Node<K,V> implements Map.Entry<K,V> {
        /**
         * hash值 对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算
        * */
        final int hash;
        /**
         * key 索引
         * */
        final K key;
        /**
         * data 数据域
         * */
        V value;
        /**
         * 下一个 node 节点
         * */
        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 值
         * */
        public final K getKey()        { return key; }
        /**
         * 获取 value 值
         * */
        public final V getValue()      { return value; }
        /**
         * key = value
         * */
        public final String toString() { return key + "=" + value; }

        /**
         * hashCode 的存在主要是用于查找的快捷性，hashCode是用来在散列存储结构中确定对象的存储地址的；
         * 注意：两个对象的hashCode相同，并不一定表示两个对象就相同
         *
         * 1.hashcode是用来查找的 例如内存中有这样的位置
         * 0  1  2  3  4  5  6  7
         * 而我有个类，这个类有个字段叫ID,我要把这个类存放在以上8个位置之一，如果不用hashcode而任意存放，那么当查找          
         * 时就需要到这八个位置里挨个去找，或者用二分法一类的算法。
         * 但如果用hashcode那就会使效率提高很多。
         * 我们这个类中有个字段叫ID,那么我们就定义我们的hashcode为ID％8，然后把我们的类存放在取得得余数那个位置。比          
         * 如我们的ID为9，9除8的余数为1，那么我们就把该类存在1这个位置，如果ID是13，求得的余数是5，那么我们就把该类         
         * 放在5这个位置。这样，以后在查找该类时就可以通过ID除 8求余数直接找到存放的位置了。
         *
         * 2.但是如果两个类有相同的hashcode怎么办那（我们假设上面的类的ID不是唯一的），例如9除以8和17除以8的余数都          * 是1，那么这是不是合法的，回答是：可以这样。那么如何判断呢？在这个时候就需要定义 equals了。
         * 也就是说，我们先通过 hashcode来判断两个类是否存放某个桶里，但这个桶里可能有很多类，那么我们就需要再通过          * equals 来在这个桶里找到我们要的类。
         * 那么。重写了equals()，为什么还要重写hashCode()呢？
         * 想想，你要在一个桶里找东西，你必须先要找到这个桶啊，你不通过重写hashcode()来找到桶，光重写equals()有什          * 么用啊
         * */
        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        /**
         * 设置新的value值，会返回旧的数据
         * */
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        /**
         * 判断对象是否相等
         * */
        public final boolean equals(Object o) {
            if (o == this) {
                return true;
            }
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue())) {
                    return true;
                }
            }
            return false;
        }
    }

使用到的一些基本参数：

    /**
     * 默认初始容量-必须为 2 的幂。
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * 最大容量，如果两个构造函数都使用参数隐式指定了更高的值，则使用该容量。
     * 最大 1073741824
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 在构造函数中未指定时使用的负载系数。
     * 加载因子 默认 0.75
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 使用树而不是列表列出 bin 的 bin 计数阈值。
     * 当将元素添加到至少具有这么多节点的bin中时，bin会转换为树。
     * 该值必须大于2，并且至少应为8，才能与删除树的假设有关，即收缩时转换回原始分类箱。
     * 当桶中元素个数超过这个值时需要使用红黑树节点替换链表节点，以便与优化速度
     *
     * 也就是当链表的长度到达8的时候，转化为树形结构
     *
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * 在调整大小操作期间用于取消树状化（拆分的）箱的箱计数阈值。
     * 应小于TREEIFY_THRESHOLD，并且最多为6以与移除下的收缩检测相啮合。
     * 当扩容时，桶中元素个数小于这个值 就会把树形的桶元素 还原（切分）为链表结构
     * 由树化转换为链式结构
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * 可将其分类为树的最小容量。
     * （否则，如果bin中的节点过多，则将调整表的大小。）应至少为4 TREEIFY_THRESHOLD以避免调整大小和树化阈值之间的冲突。
     * 当哈希表中的容量大于这个值时，表中的桶才能进行树形化
     * 否则桶内元素太多时会扩容，而不是树形化
     * 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD （256）
     *
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

基本结构参数定义：