HashMap 源码解读

HashMap 源码注解

HashMap 是以Key-Value的形式进行存储数据的，继承了AbstractMap<K, V> 类和导入Map<K, V>, Cloneable, Serializable 接口。

AbstraMap是一个抽象的Map类，这个类里面导入了Map<K, V> 接口，同时在这个类的内部定义了 SimpleEntry<K, V> 和 SimpleImmutableEntry<K, V> 内部类。

Map<K ,V> 这个接口定义了Map类型的一些基本方法，导入这个接口之后需要自己实现这些方法，是一种规范。

Serializable 接口主要是做序列化操作的。导入这个接口之后，这个类以及他的子类都可以实现序列化。

成员变量

默认初始容量 - 必须是 2 的幂

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

最大容量，在两个带参数的构造函数隐式指定更高值时使用。 必须是 2 的幂 <= 1<<30。

static final int MAXIMUM_CAPACITY = 1 << 30;

在构造函数中未指定时使用的负载因子。

static final float DEFAULT_LOAD_FACTOR = 0.75f;

使用树而不是列表的 bin 计数阈值。 将元素添加到至少具有这么多节点的 bin 时，bin 会转换为树。 该值必须大于 2 且至少应为 8，以与树移除中关于在收缩时转换回普通 bin 的假设相匹配。

    static final int TREEIFY_THRESHOLD = 8;

在调整大小操作期间取消（拆分）bin 的 bin 计数阈值。 应小于 TREEIFY_THRESHOLD，最多为 6 以在移除下进行收缩检测。

static final int UNTREEIFY_THRESHOLD = 6;

可以将 bin 树化的最小表容量。 （否则，如果 bin 中的节点过多，则表将调整大小。）应至少为 4 * TREEIFY_THRESHOLD，以避免调整大小和树化阈值之间发生冲突。

static final int MIN_TREEIFY_CAPACITY = 64;

基本哈希 bin 节点，用于大多数条目。 （请参阅下面的 TreeNode 子类，以及 LinkedHashMap 中的 Entry 子类。）

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

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(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;
        }
    }

方法介绍

构造方法

HashMap有四个构造方法，分别是：

HashMap()；
HashMap(int initialCapacity)；
HashMap(int initialCapacity, float loadFactor)
HashMap(Map<? extends K, ? extends V> m)

第一个为无参构造方法，仅仅将负载因子（LoadFactor）赋值为默认的0.75（DEFAULT_LOAD_FACTOR） 没有实例化任何东西，也没有给里面的table （Node类型的数组）分配空间，只有当你插入第一个数据的时候才会给table分配空间（详细请看putVal方法）。

第二个构造方法输入的参数是初始容量，也就是初始容量的大小，一般都是采用的2的幂，但是它的实现确实调用的第三个构造方法，输入的负载因子是之前的静态成员变量DEFAULT_LOAD_FACTOR（0.75）。

第三个构造方法的有两个构造参数，一个是负初始容量（initialCapacity），一个是负载因子（loadFactory）。初始容量的取值范围是0~2^31-1，输入的参数初始容量小于0时会抛出IllegalArgumentException(“Illegal initial capacity” + initialCapacity)；如果initialCapaty 大于 2^31 -1 ，则初始容量的大小等于 2^31 - 1；如果负载因子小于等于0 或者输入的等于NaN（0.0 / 0.0 的时候等于NaN）会抛出异常；

第四个构造方法有点是按照Map类型的直接进行赋值，默认的负载因子会置为0.75，要注意K和V的类型要一样。

其他方法

计算 key.hashCode() 并将散列的较高位（异或）传播到较低位。 由于该表使用二次幂掩码，因此仅在当前掩码之上位变化的散列集将始终发生冲突。 （众所周知的例子是在小表中保存连续整数的浮点键集。）所以我们应用了一种向下传播高位影响的变换。 位扩展的速度、效用和质量之间存在权衡。 因为许多常见的哈希集已经合理分布（因此不会从传播中受益），并且因为我们使用树来处理 bin 中的大量冲突，所以我们只是以最便宜的方式对一些移位的位进行异或以减少系统损失，以及合并最高位的影响，否则由于表边界而永远不会在索引计算中使用。

解释：object 类中的hashCode返回的是一个Int型的数据，也就是一个32位的数据，而任何数字和0进行异或运算都是他本身，h >>> 16 表示右移16位，高位用0补充。 这样才能做到低16位与高16位进行异或。

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

返回 x 的类，如果它是“类 C 实现 Comparable”的形式 "，否则为空。

static Class<?> comparableClassFor(Object x) {
        if (x instanceof Comparable) {
            Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
            if ((c = x.getClass()) == String.class) // bypass checks
                return c;
            if ((ts = c.getGenericInterfaces()) != null) {
                for (int i = 0; i < ts.length; ++i) {
                    if (((t = ts[i]) instanceof ParameterizedType) &&
                        ((p = (ParameterizedType)t).getRawType() ==
                         Comparable.class) &&
                        (as = p.getActualTypeArguments()) != null &&
                        as.length == 1 && as[0] == c) // type arg is c
                        return c;
                }
            }
        }
        return null;
    }

如果 x 匹配 kc（k 的筛选可比类），则返回 k.compareTo(x)，否则返回 0。

解释@suppressWranings 编译器要在带注释的元素中抑制的警告集。 允许重复名称。 名称的第二次和连续出现将被忽略。 出现无法识别的警告名称不是错误：编译器必须忽略它们不识别的任何警告名称。 但是，如果注释包含无法识别的警告名称，它们可以自由发出警告。
字符串"unchecked"用于抑制未经检查的警告。 编译器供应商应结合此注释类型记录他们支持的其他警告名称。 鼓励他们合作以确保相同的名称在多个编译器中工作。
返回：
要抑制的警告集

你可以理解为用了这个注解可以忽略掉需要忽略的警告。

@SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable
    static int compareComparables(Class<?> kc, Object k, Object x) {
        return (x == null || x.getClass() != kc ? 0 :
                ((Comparable)k).compareTo(x));
    }

返回给定目标容量的二次幂

这个方法很巧妙，他返回的是最小的大于或等于cap的正2次幂。

为什么这个方法就能一定返回大于或等于cap的正2次幂呢？
首先，若cap小于等于0，cap 2进制的最高位（符号位为1），最后计算的n会是负数，小于0，则会最终返回1，若cap大于 MAXIMUM_CAPACITY(2 ^ 30 )，则会返回 MAXIMUM_CAPACITY，若cap小于2 ^30 大于等于 2 ^ 29， 则会tableSizeFor 会返回 2 ^ 30, 原因如下，cap 的第29位一定为1，经过第一次或预算之后，n的第28位也一定为1，经过第二次运算后 n的第27位、26位也一定为1，然后经过第三次运算后，n的第25,24,23,22也一定为1,依次类推，最后是从第29位开始，后面的全为1，此时n小于 2^30 , n＋1之后就是 2 ^ 30。

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

​

实现 Map.putAll 和 Map 构造函数
参数：
m——地图
evict – 最初构造此映射时为 false，否则为 true（中继到方法 afterNodeInsertion）。

 final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            if (table == null) { // pre-size
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            else if (s > threshold)
                resize();
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

返回此映射中键值映射的数量。
返回：
此映射中的键值映射数

    public int size() {
        return size;
    }

如果此映射不包含键值映射，则返回true 。
返回：
如果此映射不包含键值映射，则为true

 public boolean isEmpty() {
        return size == 0;
    }

返回指定键映射到的值，如果此映射不包含键的映射，则返回null 。
更正式地说，如果此映射包含从键k到值v的映射，使得(keynull ? knull : key.equals(k)) ，则此方法返回v ； 否则返回null 。 （最多可以有一个这样的映射。）
返回值null不一定表示映射不包含键的映射； 地图也有可能将键显式映射到null 。 containsKey操作可用于区分这两种情况。
也可以看看：
put(Object, Object)

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

实现 Map.get 及相关方法
参数：
hash – 密钥的散列
钥匙——钥匙
返回：
节点，如果没有，则为 null

final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            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;
    }

待更新