HashMap类成员说明（Jdk1.8）

本篇文章来给大家解读基于Jdk1.8环境下，HashMap的类成员变量和构造器以及重要内部类的代码

目录：

　　- 类成员变量

      - HashMap构造器

　　- 重要内部类

1、类成员变量

  /**
   * The default initial capacity - MUST be a power of two.
   * HashMap默认的初始化容量：16
   */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

  /**
   * The maximum capacity, used if a higher value is implicitly specified
   * by either of the constructors with arguments.
   * MUST be a power of two <= 1<<30.
   * HashMap最大容量
   */
static final int MAXIMUM_CAPACITY = 1 << 30;

  /**
   * The load factor used when none specified in constructor.
   * HashMap扩容机制的负载因子；
   * 当添加元素数量达到容量的0.75倍时就触发数组扩容（初识容量时，当元素数量达到12就触发扩容）
   */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

  /**
   * The bin count threshold for using a tree rather than list for a
   * bin.  Bins are converted to trees when adding an element to a
   * bin with at least this many nodes. The value must be greater
   * than 2 and should be at least 8 to mesh with assumptions in
   * tree removal about conversion back to plain bins upon
   * shrinkage.
   * 链表转换为红黑树的阀值。
   * 当数组index处的链表元素数量大于8，当第九个元素也冲突了，那么在添加第九个元素时index处的数据结构会转换为红黑树。
   *
   */
static final int TREEIFY_THRESHOLD = 8;

  /**
   * The smallest table capacity for which bins may be treeified.
   * (Otherwise the table is resized if too many nodes in a bin.)
   * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
   * between resizing and treeification thresholds.
   * 红黑树的最小容量
   */
static final int MIN_TREEIFY_CAPACITY = 64;

  /**
   * The bin count threshold for untreeifying a (split) bin during a
   * resize operation. Should be less than TREEIFY_THRESHOLD, and at
   * most 6 to mesh with shrinkage detection under removal.
   * 数组index处的结构是红黑树，当红黑树的元素数量等于6时，数据结构就转变为链表。
   */
static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * The table, initialized on first use, and resized as
     * necessary. When allocated, length is always a power of two.
     * (We also tolerate length zero in some operations to allow
     * bootstrapping mechanics that are currently not needed.)
     *
     * 当前属性就是真正的hashMap容器：Node数组，用于存放put进来的所有元素，都会封装成一个个Node对象添加到当前table容器中。
     */
    transient Node<K,V>[] table;

    /**
     * Holds cached entrySet(). Note that AbstractMap fields are used
     * for keySet() and values().
     *
     * set对象，迭代器遍历HashMap时使用。
     */
    transient Set<Map.Entry<K,V>> entrySet;

    /**
     * The number of key-value mappings contained in this map.
     *
     * size表示：用于表示当前table容器中存放的真正的元素数量，从1开始计数。
     */
    transient int size;

    /**
     * The number of times this HashMap has been structurally modified
     * Structural modifications are those that change the number of mappings in
     * the HashMap or otherwise modify its internal structure (e.g.,
     * rehash).  This field is used to make iterators on Collection-views of
     * the HashMap fail-fast.  (See ConcurrentModificationException).
     *
     * modCount表示：当前table容器被修改的次数。（添加元素和删除元素都算被修改1次都会做 ++modCount运算）
     */
    transient int modCount;

    /**
     * The next size value at which to resize (capacity * load factor).
     *
     * threshold表示：table数组中的元素数量满多少个之后会触发扩容。
     * 例如：首次table容器大小是16，那么 16*0.75=12，threshold就等于12，当数组元素数量添加到12个时就会触发扩容，下一次的table容量就是32，threshold就是24。
     * @serial
     */
    // (The javadoc description is true upon serialization.
    // Additionally, if the table array has not been allocated, this
    // field holds the initial array capacity, or zero signifying
    // DEFAULT_INITIAL_CAPACITY.)
    int threshold;

    /**
     * The load factor for the hash table.
     * 当前表示容量的加载因子，说白了就是0.75,当前属性初始化时就是被 DEFAULT_LOAD_FACTOR 赋值的。
     * 当元素数量等于table容量的0.75倍就要扩容了
     * @serial
     */
    final float loadFactor;

3、HashMap构造器

    /**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and load factor.
     * HashMap的构造器
     *
     * @param  initialCapacity the initial capacity 指定HashMap的初识容量
     * @param  loadFactor      the load factor 指定HashMap的负载因子。（就是元素数量达到容量的多少倍时才会扩容）
     *
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive
     */
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        // 如果入参中指定的HashMap的初识容量超过了内置的最大值，
        // 则直接把内置的最大值赋值给初识容量，也就是说HashMap的最大容量只能是 2的30次方。
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;

        // 检查如果入参指定的负载因子小于等于0，则直接报错。
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        // 最后给HashMap的全局变量赋值
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

    /**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and the default load factor (0.75).
     *
     * 有一个初识容量参数的构造器，使用默认的负载因子0.75倍
     *
     * @param  initialCapacity the initial capacity.
     * @throws IllegalArgumentException if the initial capacity is negative.
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     * 无参的构造器，使用默认的负载因子0.75倍
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    /**
     * Constructs a new <tt>HashMap</tt> with the same mappings as the
     * specified <tt>Map</tt>.  The <tt>HashMap</tt> is created with
     * default load factor (0.75) and an initial capacity sufficient to
     * hold the mappings in the specified <tt>Map</tt>.
     * 入参是一个Map的构造器，该构造器会将入参Map中的所有元素全部put到当前HashMap表中。
     *
     * @param   m the map whose mappings are to be placed in this map
     * @throws  NullPointerException if the specified map is null
     */
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

3、重要内部类

    /**
     * Basic hash bin node, used for most entries.  (See below for
     * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
     *
     * HashMap中的每一个元素都是Node对象
     */
    static class Node<K,V> implements Map.Entry<K,V> {
        // 元素的hash值
        final int hash;
        // 元素key
        final K key;
        // 元素值
        V value;
        // 当前元素的下一个元素，如果index处的数据结构是链表则有值。
        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;
        }
    }

    /**
     * 迭代器模式，一般遍历HashMap时使用。
     * （一边删除元素一边修改或删除元素时，使用迭代器模式可防止并发修改的异常出现，
     * 但是如果一边遍历一边向HashMap中添加元素，这种情况下迭代器模式也会报错，这种情况建议使用ConcurrentHashMap）
     */
    final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public final int size()                 { return size; }
        public final void clear()               { HashMap.this.clear(); }
        public final Iterator<Map.Entry<K,V>> iterator() {
            return new EntryIterator();
        }
        public final boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>) o;
            Object key = e.getKey();
            Node<K,V> candidate = getNode(hash(key), key);
            return candidate != null && candidate.equals(e);
        }
        public final boolean remove(Object o) {
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                Object key = e.getKey();
                Object value = e.getValue();
                return removeNode(hash(key), key, value, true, true) != null;
            }
            return false;
        }
        public final Spliterator<Map.Entry<K,V>> spliterator() {
            return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
        }
        public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
            Node<K,V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next)
                        action.accept(e);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
    }