HashMap 源码解析

HashMap简介：

　　HashMap在日常的开发中应用的非常之广泛，它是基于Hash表，实现了Map接口，以键值对(key-value)形式进行数据存储，HashMap在数据结构上使用的是数组+链表。允许null键和null值，不保证键值对的顺序。

HashMap检索数据的大致流程：

　　当我们使用HashMap搜索key所对应的value时，HashMap会根据Hash算法对key进行计算，得到一个key的hash值，再根据hash值算出该key在数组中存储的位置index，然后获取数组在index位置的键值对e,再使用链表对e进行遍历，查找遍历的元素是否和给定的key相符合，若有符合的，则返回其value值。

自己手动画了一个HashMap的数据结构图：

HashMap源码分析：

　　HashMap是存储键值对的集合，实现了Map接口,下面我们看一下Map接口的定义：

/**
*映射key到value的顶级接口，不能包含重复的key，一个key最多可以映射到一个value,键和值均可为null
*/
public interface Map<K,V> {

    //返回该map包含的键值对的个数，如果键值对的个数超过了Integer.MAX_VALUE,则返会Integer.MAX_VALUE
    int size();

    //如果该Map没有包含键值对，则返回true，否则返回false
    boolean isEmpty();

    //判断该map是否包含指定的key所对应的键值对，key可以为null
    boolean containsKey(Object key);

    //判断该map是否包含指定的value所对应的键值对,若map中包含有一个及以上的key,对应指定的value,则返回true，value可以为null
    boolean containsValue(Object value);

    //返回指定的key所对应的value，若key不存在，则返回null;但是返回null的key,不代表key在map中不存在，有可能是key所对应的value为null
    V get(Object key);

    //将指定的key和value映射为一个键值对，放入map中；若之前该map中包含了指定的Key,则该key所对应的老的值oldValue将会被替换为value
    V put(K key, V value);

    //删除指定的key所对应的键值对，并返回该key对应的value
    V remove(Object key);

    //将指定的map中的键值对复制到当前map中
    void putAll(Map<? extends K, ? extends V> m);

    //清除map中所有的键值对，该操作完成后，该map就是空的了
    void clear();

    //将map中所有的key返回，由于map中的key是不能重复的，所以用Set集合的方式装载所有的key
    Set<K> keySet();

    //将map中所有的value返回，由于map中的value是可重复的，所以用Collection集合的方式装载所有的value
    Collection<V> values();

    //将map中所有的键值对Entry返回，由于map中的键值对是不可重复的（key不可重复），所以用Set集合的方式装载所有的value
    Set<Map.Entry<K, V>> entrySet();

    //Map中承载键值对的数据结构Entry
    interface Entry<K,V> {

        //返回键值对的键值key
        K getKey();

        //返回键值对的value值
        V getValue();

        //将当前键值对的value值 替换为指定的value值
        V setValue(V value);

        //判断指定的对象和当前键值对是否equals相等，若相等，则代表是同一个键值对；
        boolean equals(Object o);

        //返回当前键值对的hashCode值
        int hashCode();
    }

    //判断指定对象和当前Map的equals是否相等
    boolean equals(Object o);

    //返回当前Map的hashCode
    int hashCode();
}

下面我们具体的看一下HashMap：

    //HashMap是基于hash表来实现Map接口的，HashMap维护了下面几个变量：

    //HashMap默认的初始化大小为16
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    //HashMap包含键值对的最大容量为2^30,HashMap的容量一定要是2的整数次幂
    static final int MAXIMUM_CAPACITY = 1 << 30;

    //默认的加载因子为0.75
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    //装载键值对的内部容器Entry数组，长度一定得是2的幂
    transient Entry[] table;

    //HashMap中包含的键值对的个数
    transient int size;

    //HashMap的极限 当键值对的个数达到threshold时，数组table要扩容的
    int threshold;

    //加载因子
    final float loadFactor;

    //HashMap结构上被改变的次数，结构上的改变包括：键值对的大小的改变，修改HashMap的内部结构（比较进行了rehash操作），此属性用来保持fail-fast
    transient volatile int modCount;

接下来我们看一下HashMap的构造函数：

/**
*根据指定的容量initialCapacity和加载因子loadFactor构造HashMap
*/
    public HashMap(int initialCapacity, float loadFactor) {
        //对initialCapacity进行参数校验，若小于0，则抛出IllegalArgumentException异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        //若initialCapacity大于MAXIMUM_CAPACITY(2^30),则将MAXIMUM_CAPACITY赋值给initialCapacity
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //对参数loadFactor进行有效性校验，不能<=0,不能非数字，否则抛出IllegalArgumentException异常
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        // Find a power of 2 >= initialCapacity 找到一个2的幂的数capacity，使其不小于参数initialCapacity
        int capacity = 1;
        //若capacity小于initialCapacity,则将capacity扩大一倍
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        //设置极限，大小为 capacity * loadFactor,即(容量*负载因子)
        threshold = (int)(capacity * loadFactor);
        //创建一个大小为capacity的Entry数组table,用来保存键值对
        table = new Entry[capacity];
        //调用方法init(),进行额外的初始化操作
        init();
    }
    //init方法是空的，如果你定制额外的初始化操作，可以继承HashMap，覆盖init()方法
    void init() {

    }

    //通过指定的容量initialCapacity来构造HashMap，这里使用了默认的加载因子DEFAULT_LOAD_FACTOR 0.75
    public HashMap(int initialCapacity) {
            this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    //无参的构造函数 加载因子为DEFAULT_LOAD_FACTOR 0.75，容量为默认的DEFAULT_INITIAL_CAPACITY 16，极限为 16*0.75=12
    public HashMap() {
            this.loadFactor = DEFAULT_LOAD_FACTOR;
            threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
            table = new Entry[DEFAULT_INITIAL_CAPACITY];
            init();
    }

下面我们看一下HashMap中承载键值对的数据结构Entry的实现,Entry<K,V>是HashMap的一个静态内部类

/**
*Entry是HashMap里面承载键值对数据的数据结构，实现了Map接口里面的Entry接口，除了方法recordAccess(HashMap<K,V> m),recordRemoval(HashMap<K,V> m)外，其他方法均为final方法，表示即使是子类也不能覆写这些方法。
*/
static class Entry<K,V> implements Map.Entry<K,V> {
        //键值,被final修饰，表明一旦赋值，不可修改
        final K key;
        //value值
        V value;
        //下一个键值对的引用
        Entry<K,V> next;
        //当前键值对中键值的hash值
        final int hash;

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        //设置value值，返回原来的value值
        public final V setValue(V newValue) {
        　　V oldValue = value;
            value = newValue;
            return oldValue;
        }
        //比较键值对是否equals相等，只有键、值都相等的情况下，才equals相等
        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            //若k1 == k2(k1,k2引用同一个对象),或者k1.equals(k2)为true时，进而判断value值是否相等
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                //若v1 == v2(v1,v2引用同一个对象),或者v1.equals(v2)为true时，此时才能说当前的键值对和指定的的对象equals相等
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            //其他均为false
            return false;
        }

        public final int hashCode() {
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }

        public final String toString() {
            return getKey() + "=" + getValue();
        }

        //此方法只有在key已存在的时候调用m.put(key,value)方法时，才会被调用，即覆盖原来key所对应的value值时被调用
        void recordAccess(HashMap<K,V> m) {
        }
        //此方法在当前键值对被remove时调用
        void recordRemoval(HashMap<K,V> m) {
        }
}

下面是Hash的put方法的实现：

/**
*将指定的键key,值value放到HashMap中
*/
public V put(K key, V value) {
    //首先判断键key是否为null,若为null,则调用putForNullKey(V v)方法完成put
    if (key == null)
        return putForNullKey(value);
    //程序走到这，说明key不为null了，先调用hash(int)方法，计算key.hashCode的hash值
    int hash = hash(key.hashCode());
    //再调用indexFor(int,int)方法求出此hash值对应在table数组的哪个下标i上 (bucket桶)
    int i = indexFor(hash, table.length);
    //遍历bucket桶上面的链表元素，找出HashMap中是否有相同的key存在，若存在，则替换其value值，返回原来的value值
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        //若元素e.hash值和上面计算的hash值相等，并且(e.key == 入参key,或者入参key equals 相等 e.key)，则说明HashMap中存在了和入参相同的key了，执行替换操作
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            //在执行替换操作的时候，调用Entry对象的recordAccess(HashMap<K,V> m)方法，这个上面说过了
            e.recordAccess(this);
            return oldValue;
        }
    }
    //程序走到这，说明原来HashMap中不存在key,则直接将键值对插入即可，由于插入元素，修改了HashMap的结构，因此将modeCount+1
    modCount++;
    //调用addEntry(int,K,V,int)方法进行键值对的插入
    addEntry(hash, key, value, i);
    //由于原来HashMap中不存在key，则不存在替换value值问题，因此返回null
    return null;
}

当key为null时，HashMap是这样进行数据插入的：

//先看看HashMap中原先是否有key为null的键值对存在，若存在，则替换原来的value值；若不存在，则将key为null的键值对插入到Entry数组的第一个位置table[0]
private V putForNullKey(V value) {
    //获取Entry数组的第一个元素:table[0],然后通过e.next进行链表的遍历，若遍历过程中有元素e.key为null,则替换该元素的值
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        //说明原来之前HashMap中就已经存在key问null的键值对了，现在又插入了一个key为null的新元素，则替换掉原来的key为null的value值
        if (e.key == null) {
            V oldValue = e.value;
            e.value = value;
            //在执行替换操作的时候，调用Entry对象的recordAccess(HashMap<K,V> m)方法，这个上面说过了
            e.recordAccess(this);
            return oldValue;
        }
    }
    //程序走到这，说明HashMap中原来没有key为null的键值对，需要直接插入元素，由于插入元素，修改了HashMap的结构，因此将modeCount+1
    modCount++;
    //调用addEntry(int,K,V,int)方法进行键值对的插入,这里将入参hash设置为0，K为null,插入的位置index也为0，说明key为null的元素插入在bucket[0]第一个桶上
    addEntry(0, null, value, 0);
    return null;
}

HashMap在插入数据之前，要根据key值和hash算法来计算key所对应的hash值

//根据key的hashCode值，来计算key的hash值
static int hash(int h) {
    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

/**
*在HashMap中要找到某个元素，需要根据key的hash值来求得对应数组中的位置,如何计算这个位置就是hash算法.
*HashMap的数据结构是数组和链表的结合,所以我们当然希望这个HashMap里面的元素位置尽量的分布均匀些，尽量使得每个位置上的元素数量只有一个,
*那么当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，而不用再去遍历链表.
*所以我们首先想到的就是把hashcode对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的,但是，“模”运算的消耗还是比较大的，
*能不能找一种更快速，消耗更小的方式那？java中时这样做的 :将hash值和数组长度按照位与&来运算
*/
static int indexFor(int h, int length) {
    return h & (length-1);
}

下面我们看一看实际进行数据添加的操作addEntry方法

/**
*将指定的key,value,hash,bucketIndex 插入键值对，若此时size 大于极限threshold,则将Entry数组table扩容到原来容量的两倍
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
    //取出原来bucketIndex处的键值对e
    Entry<K,V> e = table[bucketIndex];
    //创建一个新的键值对，使用给定的hash、key、value,并将新键值对的next属性指向e,最后将新键值对放在bucketIndex处
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    //将size+1,若此时size 大于极限threshold,则将Entry数组table扩容到原来容量的两倍
    if (size++ >= threshold)
        //调用resize(int)方法，进行数组的扩容
        resize(2 * table.length);
}

我们知道HashMap采用的数组+链表来实现的，当HashMap中元素的个数size大于极限threshold时，会进行数组的扩容操作，这个操作使用resize(int newCapacity)方法实现的：

/**
*将HashMap中Entry数组table的容量扩容至新容量newCapacity,数组的扩容不但涉及到数组元素的复制，还要将原数组中的元素rehash到新的数组中，很耗时;如果能预估到放入HashMap中元素的大小，最好使用new HashMap(size)方式创建足够容量的HashMap，避免不必要的数组扩容(rehash操作)，提高效率
*/
void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    //如果原数组的大小已经为允许的最大值MAXIMUM_CAPACITY了，则不能进行扩容了，这里仅仅将极限threshold设置为Integer.MAX_VALUE，然后返回
    if (oldCapacity == MAXIMUM_CAPACITY) {
        //将极限threshold设置为Integer.MAX_VALUE
        threshold = Integer.MAX_VALUE;
        return;
    }
    //程序走到这，说明可以进行扩容，先创建容量为newCapacity的新Entry数组newTable
    Entry[] newTable = new Entry[newCapacity];
    //调用tranfer(Entry[] newTable)方法，进行数组元素的移动和rehashing
    transfer(newTable);
    //将新数组newTable赋值给table
    table = newTable;
    //计算极限threshold的最新值
    threshold = (int)(newCapacity * loadFactor);
}

//将原Entry数组table中的所有键值对迁移到新Entry数组newTable上
void transfer(Entry[] newTable) {
    //原数组赋值给src
    Entry[] src = table;
    //新数组长度为newCapacity
    int newCapacity = newTable.length;
    //遍历原数组
    for (int j = 0; j < src.length; j++) {
        //获取原数组中的元素(键值对),赋值给e
        Entry<K,V> e = src[j];
        //若元素e不为null
        if (e != null) {
            //释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）
            src[j] = null;
            //遍历元素e所对应的bucket桶内的所有元素
            do {
                //获取下一个元素next
                Entry<K,V> next = e.next;
                //重新计算键值对e在新数组newTable中的bucketIndex位置(即rehash操作)
                int i = indexFor(e.hash, newCapacity);
                //标记[1]
                e.next = newTable[i];
                //将当前元素e放入新数组的i位置
                newTable[i] = e;
                //访问下一个Entry链上的元素
                e = next;
            } while (e != null);
        }
    }
}

注释标记[1]处，将newTable[i]的引用赋给了e.next，也就是使用了单链表的头插入方式，同一位置上新元素总会被放在链表的头部位置；这样先放在一个索引上的元素终会被放到Entry链的尾部(如果发生了hash冲突的话)；

若某个桶上面的元素不止一个，则会行成一个链表，在resize过程中，会导致链表逆序排列。比如在第i个桶内，有元素tab[i1]=a -> tab[i2]=b -> tab[i3]=c -> tab[i4]=d,

在resize后，比如会放到新的数组下标j处，则新的链表为newTab[j1]=d -> newTab[j2]=c -> newTab[j3]=b -> newTab[j4]=a

下面我们看一下HashMap检索数据的操作：

//获取指定key所对应的value值
public V get(Object key) {
    //若key==null,则直接调用getForNullKey()方法
    if (key == null)
        return getForNullKey();
    //到这说明key != null,先获取key的hash值
    int hash = hash(key.hashCode());
    //在indexFor(int hash,int length)获取key落在Entry数组的哪个bucket桶上，获取该bucket桶上的元素e,进而遍历e的链表，找相对应的key,若找到则返回key所对应的value值，找不到则返回null
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        //若元素e.hash == 上面计算的hash值，并且(e.key 和入参key是同一个对象的引用，或者e.key和入参key equals相等)，
        //则认为入参key和当前遍历的元素e的key是同一个,返回e的value值
        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
            return e.value;
    }
    //上面遍历了一遍也没有找到，则返回null
    return null;
}

//获取key为null的value值，由上面putForNullKey方法可知，key为null的键值对，被放在了Entry数组table的第一个bucket桶(table[0])
private V getForNullKey() {
    //获取Entry数组table的第一个元素e,从e开始往下遍历，若找到元素e.key 为null的，则直接返回该元素e.value值
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        //找到元素e.key 为null的，则直接返回该元素e.value值
        if (e.key == null)
            return e.value;
    }
    //从table[0]开始，遍历链表一遍，没有找到key为null的，则返回null
    return null;
}

//获取指定key所对应的键值对Entry,先获取key的hash值，再获取该hash值应放入哪个hash桶，然后遍历该桶中的键值对，若有则返回该键值对；若没有则返回null
final Entry<K,V> getEntry(Object key) {
    //若key为null,则hash值为0；若key != null,则利用hash(int)计算key的hash值
    int hash = (key == null) ? 0 : hash(key.hashCode());
    //获取该hash值应放入哪个hash桶,并遍历该hash桶
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        //若元素e.hash == hash,并且(e.key == key，或者 key.equals(e.key)为true)，则认为入参key和当前遍历的元素e.key是同一个，返回该元素e
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    //若没有则返回null
    return null;
}

//判断HashMap中是否含有指定key的键值对，内部用getEntry(Object key)来实现
public boolean containsKey(Object key) {
    return getEntry(key) != null;
}

//将指定Map中的所有元素(键值对)拷贝到当前HashMap中，对于当前HashMap中存在的key,则进行value值的替换
public void putAll(Map<? extends K, ? extends V> m) {
    //若指定的Map中没有元素，则直接返回
    int numKeysToBeAdded = m.size();
    if (numKeysToBeAdded == 0)
        return;

    //若必要，则进行数组的扩容
    if (numKeysToBeAdded > threshold) {
        int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
        if (targetCapacity > MAXIMUM_CAPACITY)
            targetCapacity = MAXIMUM_CAPACITY;
        //计算新的容量
        int newCapacity = table.length;
        while (newCapacity < targetCapacity)
            newCapacity <<= 1;
        //若新容量大于目前数组的长度，则调用resize(int)进行扩容
        if (newCapacity > table.length)
            resize(newCapacity);
    }
    //获取指定Map的迭代器，循环调用put(K k,V v)方法，进行键值对的插入
    for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
        Map.Entry<? extends K, ? extends V> e = i.next();
        put(e.getKey(), e.getValue());
    }
}

下面看下HashMap的remove操作：

/**
* 删除指定key所对应的元素
*/
public V remove(Object key) {
    //调用方法reomveEntryForKey(Object key)来删除并获取指定的entry
    Entry<K,V> e = removeEntryForKey(key);
    //若entry为null，则返回null；否则返回entry的value值
    return (e == null ? null : e.value);
}

/**
*移除并返回指定key所关联的键值对entry,若HashMap中没有键值对和指定的key相关联，则返回null
*/
final Entry<K,V> removeEntryForKey(Object key) {
    //若key为null,则hash值为0；若key != null,则利用hash(int)计算key的hash值
    int hash = (key == null) ? 0 : hash(key.hashCode());
    //获取key应放入的在数组中的位置索引i
    int i = indexFor(hash, table.length);
    //标识前一个元素
    Entry<K,V> prev = table[i];
    //标识遍历过程中的当前元素
    Entry<K,V> e = prev;
    //遍历bucket桶table[i]中的元素，寻找对应的key
    while (e != null) {
        //当前元素的下一个元素
        Entry<K,V> next = e.next;
        Object k;
        //元素e.hash和上面计算的hash值相等，并且(key == e.key 或者key.equals(e.key) 为true)，说明找到了指定key所对应的键值对
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k)))) {
            //由于删除了一个元素，修改了HashMap的结构，因此将modCount+1
            modCount++;
            //将size-1
            size--;
            //若待查找的元素为桶内的第一个元素，则当前元素的下一个元素next放入数组中位置i中
            if (prev == e)
                table[i] = next;
            //否则将上一个元素的next属性指向 当前元素的next
            else
                prev.next = next;
            //当元素被remove时，调用Entry对象的recordRemove(Map<K,V> m)方法
            e.recordRemoval(this);
            //返回找到的当前元素
            return e;
        }
        //程序走到这，说明当前元素不是要查找的元素；则将当前元素赋值给上一个元素，将下一个元素赋值给当前元素，以完成遍历
        prev = e;
        e = next;
    }

    return e;
}

//判断HashMap中是否包含指定的对象value
public boolean containsValue(Object value) {
    //若value为null，则调用containsNullValue()方法处理
    if (value == null)
        return containsNullValue();
    //将数组table赋值给tab
    Entry[] tab = table;
    //遍历数组tab的每个索引位置(此层循环对应数组结构)
    for (int i = 0; i < tab.length ; i++)
        //对应指定的索引位置i,遍历在索引位置i上的元素(此层循环对应链表结构)
        for (Entry e = tab[i] ; e != null ; e = e.next)
            //若某个元素e.value和指定的value equals相等，则返回true
            if (value.equals(e.value))
                return true;
    //遍历完成没有找到对应的value值，返回false
    return false;
}

//判断HashMap是否包含value为null的元素
private boolean containsNullValue() {
    //将数组table赋值给tab
    Entry[] tab = table;
    //遍历数组tab的每个索引位置(此层循环对应数组结构)
    for (int i = 0; i < tab.length ; i++)
        //对应指定的索引位置i,遍历在索引位置i上的元素(此层循环对应链表结构)
        for (Entry e = tab[i] ; e != null ; e = e.next)
            //若某个元素e.value == null，则返回true
            if (e.value == null)
                return true;
    //没有找到value值为null的，返回false
    return false;
}

//清除HashMap中所有的键值对，此操作过后，HashMap就是空的了
public void clear() {
    //要删除所有的元素，肯定会对HashMap的结构造成改变，因此modCount+1
    modCount++;
    Entry[] tab = table;
    //遍历数组，将数组中每个索引位置的设置为null
    for (int i = 0; i < tab.length; i++)
        tab[i] = null;
    //将size 修改为0
    size = 0;
}

现在看一下上面没有讲的一个构造函数:

//构造一个新的HashMap，以承载指定Map中所有的键值对，使用默认的加载因子DEFAULT_LOAD_FACTOR
public HashMap(Map<? extends K, ? extends V> m) {
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                  DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
    //调用putAllForCreate(Map<? extends K, ? extends V>)方法完成元素的迁移
    putAllForCreate(m);
}

private void putAllForCreate(Map<? extends K, ? extends V> m) {
    for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
        Map.Entry<? extends K, ? extends V> e = i.next();
        //在迭代器循环中调用putForCreate(K k,V v)来实现元素的创建
        putForCreate(e.getKey(), e.getValue());
    }
}

//该方法和put方法不同，它不会进行数组的扩容resize,和对modCount的检查
private void putForCreate(K key, V value) {
    //若key为null,则hash值为0；若key != null,则利用hash(int)计算key的hash值
    int hash = (key == null) ? 0 : hash(key.hashCode());
    //求key应该放入哪个hash桶(bucket)内
    int i = indexFor(hash, table.length);
    //遍历链表，若key之前在Map中已经有了，则直接返回
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k)))) {
            e.value = value;
            return;
        }
    }
    //调用createEntry(int hash,K k,V v,int bucketIndex)方法完成键值对的创建并加入到链表中
    createEntry(hash, key, value, i);
}

void createEntry(int hash, K key, V value, int bucketIndex) {
    //将bucketIndex位置的元素取出来
    Entry<K,V> e = table[bucketIndex];
    //创建一个新的键值对，使用给定的hash、key、value,并将新键值对next指向e,最后将新键值对放在bucketIndex处
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    //将数组大小size + 1
    size++;
}

　　下面我们讲下HashMap的负载因子loadfactor, 所谓负载因子就是散列表的实际元素数目(n)/散列表的容量(m), 它衡量的是一个散列表的空间的使用程度，默认情况下loadfactor是0.75，它的作用是当HashMap中元素的个数size 大于(HashMap的容量capacity * 负载因子loadfactor)时，该HashMap便会进行扩容resize。

　　我们先说下hash冲突：

　　当利用HashMap存数据的时候，先根据key的hashcode值来计算key的hash值(利用hash函数)，再根据hash值来计算该key在数组table中的位置index（hash & (length-1)）,比如我们要存两个键值对key1-value1和key2-value2,

如果key1、key2分别通过hash函数计算的hash值hash1、hash值hash2 相等，那key1和key2一定会落在数组table的同一个位置上，这就产生了冲突，这个冲突是由不同的key值但是却相同的hash值引起的，称之为hash冲突。HashMap解决hash冲突的方式就是链表，虽然key1-value1和key2-value2这两个键值对落在了数组table的同一个位置上，但是它们是链表的方式连接在一起，当HashMap查找key1时，就需要遍历这个链表了。

当负载因子越大的时候，出现hash冲突的可能性越大，这意味着数组table中某个具体的桶bucket上不止有一个元素（此时就构成了链表了）可能性增大，在检索数据的时候需要遍历链表的可能性增大，因此检索的效率就比较低（耗时长），但是空间的利用率越高。

当负载因子越小的时候，出现hash冲突的可能性越小，这意味着数组table中某个具体的桶bucket上不止有一个元素（此时就构成了链表了）可能性减小了，在检索数据的数据需要遍历链表的可能性减小，因此检索的效率就比较高，但是空间利用率越低。

　　上面的源码解析了提到了HashMap的容量一定得是2的整数此幂(2^n),这又是问什么呢？

　　通过上面的源码我们知道：根据hash值求该hash值在数组中的位置的实现是： hash & (length-1)，当数组table的长度length为2的整数次幂的时候，那（length-1）二进制表示形式从低位开始一定都是1，直到为0，如果length依次为2,4,8,16,32，64，则(length-1)一次为1,3,7,15,31,63，那(length-1)的二进制形式依次为1,11,111,1111,11111，我们知道二进制的与运算&，当一方位数全是1的时候，进行&运算的结果完全取决于另外一方。

比如从0开始到15,依次和15进行&运算，看看结果的平均分布情况：

操作数0-15	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111
15的二进制	1111	1111	1111	1111	1111	1111	1111	1111	1111	1111	1111	1111	1111	1111	1111	1111
进行位与&操作结果	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111

通过位与&操作后，发现0-15完全平均的落在了数组的各个索引位置

下面通过一个小例子予以验证：

public class HashDemo {

    private final int[] table;

    public HashDemo(int size) {
        this.table = new int[size];
        for (int i = 0; i < size; i++) {
            table[i] = i;
        }
    }

    //求key所对应的在数组中的位置
    public int index(int key){
        //求hash值
        int hash = hash(key);
        //返回key所对应的在数组中的位置
        return hash & (table.length-1);
    }

    //HashMap中hash函数的实现,求hash值
    public int hash(int h){
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    public static void main(String[] args) {
        Map<String,Integer> keyToNumber = new HashMap<String, Integer>();
        int size = 16;
        HashDemo hashDemo = new HashDemo(size);
        int testSize = 1000;
        for (int i = 0; i < testSize; i++) {
            int index = hashDemo.index(i);
            Integer number = keyToNumber.get("key" + index);
            if (number == null) {
                keyToNumber.put("key"+index,1);
            }else {
                keyToNumber.put("key"+index,keyToNumber.get("key"+index)+1);
            }
        }
        Iterator<Map.Entry<String, Integer>> it = keyToNumber.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            System.out.println(entry.getKey() + "   == "+entry.getValue());
        }
    }

}

当我们将size设置为16 （2的4次幂）时，控制台输出：

key4   == 62
key3   == 62
key6   == 62
key5   == 62
key0   == 62
key2   == 62
key1   == 62
key10   == 63
key11   == 63
key8   == 63
key7   == 62
key9   == 63
key15   == 63
key14   == 63
key13   == 63
key12   == 63

由上面的输出可见，数据非常平均的分配在了数组的16个索引位置，

当size设置为非2的整数次幂的时候，比如50，这时控制台输出：

key0   == 120
key17   == 124
key16   == 124
key1   == 120
key49   == 128
key48   == 128
key32   == 128
key33   == 128

由此可见1000个数据只分配在了8个索引位置上。

使用HashMap的注意事项：

　　1.HashMap采用数组+链表的形式存储数据，当预先知道要存储在HashMap中数据量的大小时，可以使用new HashMap(int size)来指定其容量大小，避免HashMap数组扩容导致的元素复制和rehash操作带来的性能损耗。

　　2.HashMap是基于Hash表、实现了Map接口的，查找元素的时候，先根据key计算器hash值，进而求得key在数组中的位置，但是要尽量避免hash冲突造成的要遍历链表操作，因此在我们手动指定HashMap容量的时候，容量capacity一定得是2的整数次幂，这样可以让数据平均的分配在数组中，减小hash冲突，提高性能。

　 3.HashMap是非线程安全的，在多线程条件下不要使用HashMap，可以使用ConcurrentHashMap代替。