超详细的逐句介绍Java高级接口之HashMap底层源码讲解（一）

一、HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。它集成大量的方法，应用于数据结构与算法中。下面我将介绍HashMap的内部方法。

二、HashMap的内部方法

下面是HashMap的初始化结构，定义了HashMap继承于AbstractMap，它连接了Map<K,V>, Cloneable, Serializable 三个接口。

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    }

下面定义了HashMap串行ID

private static final long serialVersionUID = 362498820763181265L;

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

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//默认16

定义最大容量，为2的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 树化的最小表容量。

static final int MIN_TREEIFY_CAPACITY = 64;

下面定义Node<k,v>节点

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

创建node的哈希值

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

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

 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。

static int compareComparables(Class<?> kc, Object k, Object x) {
        return (x == null || x.getClass() != kc ? 0 :
                ((Comparable)k).compareTo(x));
    }

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

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

定义转瞬即逝的node节点

transient Node<K,V>[] table;

保存缓存的 entrySet()。请注意，AbstractMap 字段用于 keySet() 和 values()。

transient Set<Map.Entry<K,V>> entrySet;

此映射中包含的键值映射数。

transient int size;

该 HashMap 被结构修改的次数该字段用于在 HashMap 的 Collection-views 上创建迭代器快速失败。

transient int modCount;

要调整大小的下一个大小值（容量负载因子）。

final float loadFactor;

构造一个具有指定初始容量和负载因子的空 HashMap。

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

构造一个具有指定初始容量和默认负载因子 (0.75) 的空 HashMap。

 public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

构造一个具有默认初始容量 (16) 和默认负载因子 (0.75) 的空 HashMap

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; 
    }

构造一个与指定 Map 具有相同映射关系的新 HashMap。 HashMap 是使用默认负载因子 (0.75) 和足以在指定 Map 中保存映射的初始容量创建的。

public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

实现 Map.putAll 和 Map 构造函数

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