HashMap源码学习（基于jdk1.8）

​
HashMap数据结构示意图

//默认初始化容量，必须是2的幂次

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

//最大容量，如果指定其它较大值时，则必须是2的幂次，且小于等于1<<30

static final int MAXIMUM_CAPACITY = 1 << 30;

//默认负载因子

static final float DEFAULT_LOAD_FACTOR = 0.75f;

//树化结构最小链节点数，即单个表节点上的链节点超过8个时才会转换为红黑树进行存储

static final int TREEIFY_THRESHOLD = 8;

//树结构转为链结构时的树节点数，即与上面的参数相对应

static final int UNTREEIFY_THRESHOLD = 6;

//树化结构的最小表节点数，即小于这个数时，不会进行链表转红黑树，而是给表扩容

static final int MIN_TREEIFY_CAPACITY = 64;

内部类Node<K,V>不再赘述，比较简单

/*
* 计算node在map中存取时使用的hash值
*/
    static final int hash(Object key) {
        int h;
        //当key不为null时，将key的hashcode的前16位和后16位做异计算返回
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

/*
* 判断若x实现了Comparable<C>接口，则返回x的类型，否则返回空
*/

    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类型则返回0，否则返回x和k的对比值
*/

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

/*
* 计算返回table的size，结果值为大于或等于cap的最小2的幂次
*/

    static final int tableSizeFor(int cap) {
// 计算前减1，防止cap已经是2的幂次时获取的值为cap*2
        int n = cap - 1;
//以下操作即将cap的二进制值后续值全部补1，如01000010，则补充后为01111111
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
//返回计算值+1，得到大于等于cap的最小2幂次值
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

// 存储链/树的表格，首次使用时初始化大小，且大小必须为2的幂次
    transient Node<K,V>[] table;

//存储值的集合，用于keySet() 和 values()方法
    transient Set<Map.Entry<K,V>> entrySet;

// hashmap实际存储的节点数，put或remove等操作时都会更新
    transient int size;

//每次成功调整hashmap结构时增加一次，主要用于防止在map上建立子视图时进行调整结构操作
    transient int modCount;

// 要调整hash表大小的下一个大小值(容量*负载因子)
    int threshold;

//哈希表的加载因子
    final float loadFactor;

/*
* 带初始化容量和负载因子的构造函数
*/
    public HashMap(int initialCapacity, float loadFactor) {
        //初始容量入参小于0时抛出异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        //初始容量入参大于最大容量时，使用最大容量（1<<30)
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //负载因子入参小于等于0或者为空时，抛出异常
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        //hash表调整大小的阙值为大于等于初始容量入参的最小2幂次（不应该是容量*负载因子吗？）
        this.threshold = tableSizeFor(initialCapacity);
    }

//带初始化容量入参的构造函数
    public HashMap(int initialCapacity) {
//使用默认负载因子0.75f构造hashmap
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

//不带入参的构造函数
    public HashMap() {
//负载因子使用默认值0.75f
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

-------- 由此可见，hashmap的以上构造函数只是确认了负载因子和阙值，并没有做初始化hash表等其它事情

//映射一个已有map的构造函数，负载因子使用默认值0.75f
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

//将已有map对象全量加载到当前hashmap下
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//这里需要注意，如果m为null则会抛空指针
        int s = m.size();
//m大小为空时，直接返回
        if (s > 0) {
//如果table未初始化
            if (table == null) { // pre-size
//按现hashmap的负载因子计算阙值（+1.0f是为了防止计算得到小数时，最后转为int时小于原址）
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
//当m计算出的阙值大于原阙值时，重新计算阙值大小
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
//当m的size大于当前阙值时，调整大小
            else if (s > threshold)
                resize();
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
//按循环put各个对象
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

//返回hashmap内entry个数

    public int size() {
        return size;
    }

//判断hashmap内是否为空
    public boolean isEmpty() {
        return size == 0;
    }
/*
*hashmap的判空用isEmpty和size()==0逻辑上是一致，但是其它map实现类未必，所以map判空时尽量使用isEmpty()
*/

//从hashmap中取出相应key的value，不存在是返回null。主要学习getNode的逻辑
    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) =