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 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 e : table) {//遍历整个数组
while(null != e) {//将同一个位置的元素按链表顺序取出
HashMapEntry 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 e = table[bucketIndex];//获取要存放元素的位置的链表头
table[bucketIndex] = new HashMapEntry<>(hash, key, value, e);
size++;
}
看下HashMapEntry的构造
HashMapEntry(int h, K k, V v, HashMapEntry n) {
value = v;
next = n;//将原来链表的头放在新建元素的next位置上,链表的插入
key = k;
hash = h;
}
这样就完成了hashMap的扩容了。