HashMap的扩容条件与过程

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

面试中老是会问什么时候HashMap会扩容？并且还要描述扩容过程中数据是如何迁移的
HashMap 的实例有两个参数影响其性能：“初始容量” 和 “加载因子”。容量 是哈希表中桶的数量，初始容量 只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，并且要存放的位置已经有元素了（hash碰撞），必须满足这两个条件，才要对该哈希表进行 rehash 操作，会将容量扩大为原来两倍。通常，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本。
一步一步看。
构造方法

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY) {
        initialCapacity = MAXIMUM_CAPACITY;
    } else if (initialCapacity < DEFAULT_INITIAL_CAPACITY) {
        initialCapacity = DEFAULT_INITIAL_CAPACITY;
    }

    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
 
    threshold = initialCapacity;
    init();
}


public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR); //默认容量为16，必须是2的倍数，与key值生成数组索引有关，加载因子0.75
}


public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, 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);
    inflateTable(threshold);

    putAllForCreate(m);
}

扩容发生肯定是发生在存值的时候，看下HashMap的put（）方法

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {//如果散列表是空的
        inflateTable(threshold);//会去建一个表
    }
    if (key == null) //hashmap会把key为空的放在数组头部
        return putForNullKey(value);
    int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key);//根据key生成hash值
    int i = indexFor(hash, table.length); //生成散列表中的索引，也就是数组下标
    for (HashMapEntry<K,V> e = table[i]; e != null; e = e.next) {//遍历链表，看是否存在key值一样的对象，如果有的话就替换value值
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    //如果没找到key值一样的，就添加
    addEntry(hash, key, value, i);
    return null;
}

如何根据hash值生成数组下标，看indexFor()

static int indexFor(int h, int length) {
    // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
    return h & (length-1);
   //为什么长度要是偶数，因为hash值与length的与值不能超过length -1,要不然数组/就越界了，例如hash值是11000111B，length = 1000B,h & (length-1) = 111B,这样得到数组索引肯定不会越界了
}

如果添加的是一个新元素

void addEntry(int hash, K key, V value, int bucketIndex) {
    //  什么时候扩容？当前个数大于等于阈值，并且是并且，要存放值的位置已经有元素了
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);//数组长度变为原来两倍
        hash = (null != key) ? sun.misc.Hashing.singleWordWangJenkinsHash(key) : 0;
        bucketIndex = indexFor(hash, table.length);//如果扩容完成，重新取得当前元素应该存放的位置
    }
    createEntry(hash, key, value, bucketIndex);//把元素放到该放的位置
}

看resize方法

void resize(int newCapacity) {
    HashMapEntry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
    HashMapEntry[] newTable = new HashMapEntry[newCapacity];//新建一个数组
    transfer(newTable);//完成新旧数组拷贝
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

看下旧数组怎么拷贝到新数组里面，扩容过程

void transfer(HashMapEntry[] newTable) {
    int newCapacity = newTable.length;
    for (HashMapEntry<K,V> e : table) {//遍历整个数组
        while(null != e) {//将同一个位置的元素按链表顺序取出
            HashMapEntry<K,V> next = e.next;//先将当前元素指向的下一个元素存起来，一个一个存放到新表的位置中，记住不一定是同一位置，因为长度变了
            int i = indexFor(e.hash, newCapacity);//根据新数组长度，重新生成数组索引
            e.next = newTable[i];//将当前位置的元素链表头指向即将新加入的元素，
            newTable[i] = e;//然后放入数组中，完成同一位置元素链表的拼接，最先添加的元素总在链表末尾
            e = next;//然后继续循环，拿出下一个元素
        }
    }
}

最后看一下怎么把元素添加到数组的链表中的

void createEntry(int hash, K key, V value, int bucketIndex) {
    HashMapEntry<K,V> e = table[bucketIndex];//获取要存放元素的位置的链表头
    table[bucketIndex] = new HashMapEntry<>(hash, key, value, e);
    size++;
}

看下HashMapEntry的构造

HashMapEntry(int h, K k, V v, HashMapEntry<K,V> n) {
    value = v;
    next = n;//将原来链表的头放在新建元素的next位置上，链表的插入
    key = k;
    hash = h;
    }

这样就完成了hashMap的扩容了。