hashMap 源码注释分析（一）

package MyHashMap;

import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import sun.misc.SharedSecrets;



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

    private static final long serialVersionUID = 362498820763181265L;


    /**
     * 默认初始容量-必须是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;

    /**
     * 使用树而不是数组作为储存数据的阈（yu）值
     * 数组将转换为红黑树该值必须大于2，并且至少应为8，
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * 在哈希表扩容时，如果发现链表长度小于 6，则会由树重新退化为链表
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * 在转变成树之前，还会有一次判断，只有键值对数量大于 64 才会发生转换。
     * 这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

    /**
     * 当数组节点超过 TREEIFY_THRESHOLD 阈值时使用（有关TreeNode子类的信息，请参见下文，有关Entry子类的信息，请参见LinkedHashMap。）
     *
     * 该类为静态内部类，hashMap使用静态内部类创建链表
     */
    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;
        }
    }

    /* ---------------- Static utilities -------------- */

    /**
     * 计算key的hash值
     * >>表示右移，如果该数为正，则高位补0，若为负数，则高位补1；
     * >>>表示无符号右移，也叫逻辑右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0。
     * 使用key的hash值与该hash值右移16位异或
     * 异或的定义，两个数的二进制表示进行按位异或，相同为0 ， 相异为1，
     */
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    /**
     * 如果x的类型实现Comparable<T> 返回x的 Class<?>
     * 如果不是返回 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) // 将x.getClass() 赋值给c
                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;
    }


    public static void main(String[] args) {
        int n = 33 - 1;
        System.out.println(Integer.toBinaryString(n));
        n |= n >>> 1;
        System.out.println(Integer.toBinaryString(n));
        n |= n >>> 2;
        System.out.println(Integer.toBinaryString(n));
        n |= n >>> 4;
        System.out.println(Integer.toBinaryString(n));
        n |= n >>> 8;
        System.out.println(Integer.toBinaryString(n));
        n |= n >>> 16;
        System.out.println(n);
    }

    /**
     * Returns k.compareTo(x) if x matches kc (k's screened comparable
     * class), else 0.
     */
    @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));
    }

    /**
     * 对于给定的目标容量，返回两倍大小的幂。
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1; //保证容量值输入为2的幂时不会被再次扩容2倍  int n = 33 - 1; 100000
        n |= n >>> 1;// 110000   n 与 n逻辑右移1位 赋值给n  目标为：把二进制数的所有位都变成1
        // 1移1位与运算变成两个1 ，两个1移两位变成4个 4个变成8个  8个变16个 16个变32 覆盖所有的数  完成扩容。完美！！！
        n |= n >>> 2;//111100         ....
        n |= n >>> 4;//111111       .....
        n |= n >>> 8;//111111
        n |= n >>> 16;//111111
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

    /* ---------------- Fields -------------- */

    /**
     * transient修饰符的作用是使该变量在序列化的时候不会被储存。
     * table是储存了容器中所有的元素(地址)
     * HashMap的哈希桶数组，非常重要的存储结构，用于存放表示键值对数据的Node元素。
     */
    transient Node<K,V>[] table;

    /**
     * HashMap将数据转换成set的另一种存储形式，这个变量主要用于迭代功能。
     */
    transient Set<Map.Entry<K,V>> entrySet;

    /**
     * HashMap中实际存在的Node数量，注意这个数量不等于table的长度，
     * 甚至可能大于它，因为在table的每个节点上是一个链表（或RBT）结构，可能不止有一个Node元素存在。
     */
    transient int size;

    /**
     * HashMap的数据被修改的次数，这个变量用于迭代过程中的Fail-Fast机制，
     * 其存在的意义在于保证发生了线程安全问题时，能及时的发现（操作前备份的count和当前modCount不相等）并抛出异常终止操作。
     */
    transient int modCount;

    /**
     * The next size value at which to resize (capacity * load factor).
     *HashMap的扩容阈值，在HashMap中存储的Node键值对超过这个数量时，自动扩容容量为原来的二倍。
     * @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;

    /**
     * HashMap的负载因子，可计算出当前table长度下的扩容阈值：threshold = loadFactor * table.length。
     *
     * @serial
     */
    final float loadFactor;

    /* ---------------- Public operations -------------- */

    /**
     *hashMap的构造器，
     * @param  initialCapacity 初始化大小容量 默认16
     * @param  loadFactor      负载因子 默认0.75
     * @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);
        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);//把容量转为范围内最大2的幂赋值给扩容阈值
    }

    /**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and the default load factor (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).
     */
    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>.
     *
     * @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);
    }

    /**
     * Implements Map.putAll and Map constructor
     * putALL 方法  把map添加到当前map中。
     *
     * @param m the map
     * @param evict false when initially constructing this map, else
     * true (relayed to method afterNodeInsertion).
     */
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            if (table == null) { //如果map的容器是空的，没有初始化
                float ft = ((float)s / loadFactor) + 1.0F; // threshold = loadFactor * table.length。计算容器需要的大小
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)//如果容器大小大于当前的扩容阈值，则阈值扩容为范围内最大2的幂
                    threshold = tableSizeFor(t);
            }
            else if (s > threshold)//如果table 不为 null 且 传入的map的大小大于当前的扩容阈值
                resize();//table 扩容
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {//给table赋值， 就是put操作
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);// put操作
            }
        }
    }

HashMap 超详细注释解读