HashMap一直是一个使用率极高的数据数据类型,用于映射处理,1.8的jdk改动,hashMap也有很大影响。今天我们根据源码,看看HashMap的存储结构、内部功能,也大致比较一下1.8和1.7的区别。
我们今天要时候的HashMap,是根据键的hashCode值存储数据的,什么是哈希表呢?
散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。
因为HashMap使用的是HashCode存储键,一般可以根据key直接定位到对应的value,所以具有很强的快速访问能力,不考虑哈希冲突的情况下,仅需一次定位即可完成,时间复杂度为O(1)。HashMap允许以null为key存值,但只允许一次。HashMap非线程安全,要是想要在多线程下使用,可以使用ConcurrentHashMap。
HashMap类:
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
{
Java为数据结构的映射定义了一个接口Java.util.Map,此接口主要有四个常用实现类HashMap、Hashtable、LinkedHashMap和TreeMap,下图可以理解他们之间的关系(网上拿的):
存储结构
当我们对某个元素进行哈希运算,得到一个存储地址,然后要进行插入的时候,发现已经被其他元素占用了,其实这就是所谓的哈希冲突,也叫哈希碰撞。哈希冲突的解决方案有多种:再散列函数法、链地址法。而HashMap即是采用了链地址法,也就是数组+链表的方式。(1.8加了红黑树)。HashMap主体是一个数组,当要查找或者添加时,如果定位的地方只有数组,那么添加和删除都很快,时间复杂度为O(1);如果定位的地方含有链表,添加会在链表的头部添加,时间复杂度依然是O(1),但是查找则需要遍历整个链,相对较慢,所以一个HashMap中,链越少越好。我们先来看一张图帮助具象化理解HashMap的内部结构:
1.8中,当一个桶内键值对的个数大于8时,会转为红黑树。
1.8中,桶内装的对象叫做Node ,本质和Entry是一个东西。多了些get set和equals
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
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;
}
}
经过上面初步了解,我们已经知道了 bucket,table,Entry(Node),下面我们来了解一下HashMap类中几个关键的字段。
先从构造方法入手,HashMap一共提供了四种构造方法:
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;
threshold = initialCapacity;
init();
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
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);
}
从构造方法可以看出,主要干的事就两个:1.参数是否合法。2.改变静态变量的值。
设计到的重要的变量一共有:
loadFactor,threshold , default_initial_capacity, default_loadFactor, max_capacity
查看源码我们看到类中的字段:
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
transient int size;
int threshold;
final float loadFactor;
transient int modCount;
上图提到,table就是个Entry数组,capacity是指table的长度,默认是16,最大是1<<30。在HashMap中,哈希桶数组table的长度大小必须为2的n次方,
int capacity = roundUpToPowerOf2(toSize);
private static int roundUpToPowerOf2(int number) {
// assert number >= 0 : "number must be non-negative";
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
这个判定真的很有用,相当于在后面取模,扩容时做了优化。
modCount是指当前map内部结构改变的次数。(值改变不是内部结构改变,只有put或者remove等改变键值对的时候才是内部结构的改变)
size这个字段其实很好理解,就是HashMap中实际存在的键值对数量
重点是剩下的几个:
threshold(阀值): 是指map对象能容纳的键值对的最大个数,当HashMap大小大于阀值,HashMap将扩容两倍(稍后细讲扩容)
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
也就是说:当table数组的长度确定之后,负载因子越大,能容纳的键值对越多。
loadFactor: 负载因子,默认值为0.75,建议不要修改,除非情况很特殊,如果你内存空间充裕,追求时间效率,可以降低负载因子的值,反之,增大负载因子,这个值可以大于1.
对于红黑树,说实话,很有效,也很麻烦,想了解的来这里:初步了解红黑树
内部方法
HashMap的内部方法有挺多的,其中以put最为典型,这次我们就以put方法来进行分析,1.8中因为加入了红黑树,所以代码拉长了很多,思路与1.7中还是一致的,为了简洁,我们这次以1.7的源码为例分析。
public V put(K key, V value) {
//如果table为空数组,则为table分配一个默认大小的空间(1<<4=16)
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
//如果key为null,则存储在table[0],或者table[0]所在的链上
if (key == null)
return putForNullKey(value);
int hash = hash(key);//对key的hashcode进行重新计算,保证散列是均匀的
int i = indexFor(hash, table.length);//定位当前entry在table中的实际位置
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;//如果要put的数据key已经存在,则覆盖其value,返回就value
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);//一个空的实现函数。
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);//如果要put的entry不存在,则新增一个entry
return null;
}
inflateTable:
private void inflateTable(int toSize) {
// Find a power of 2 >= toSize
int capacity = roundUpToPowerOf2(toSize);//上文提到,保证capacity是2的n次幂
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//除非你特意的改变负载因子(loadFactor)的值>1,不然capacity的值不会大于Max,所以多数情况下去的是前者,两个的乘积
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
计算hashCode,运用了很多位运算,hash():
1.7:
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}:
1.8:
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
不管是添加,删除,还是查找,定位桶的位置都是很关键的,也是要做的第一步。我们看看定位的方法: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);
}
上面提到,因为hashMap是数据+链表,所以我们希望HashMap里面的元素分布的尽量均匀一些,也就是说一个桶中的元素尽可能的少,这样我们就可以定位到桶以后直接获得元素,而不需要遍历链表,使查询速度大大加快。所以定位数组索引的位置,直接决定hashMap的性能。因为相同的hashCode经过hash之后得到的值是相同的,我们希望这个hash值能在数组中均匀的分布,第一想到的就是对数组的长度进行取模,也就是hash%length(capacity),但是取模这个操作对性能影响是比较大的,而HashMap中是这样做的 hash&(length-1),因为length一定是2的n次幂,所以hash&(length-1)等价于hash对length取模:我们来看个例子,假如hash值是7,数组长度legth为4,那么取模就是7%4=3,当我们用位与(&)的时候是这样的:
结果相同,但是位运算比取模的效率要高上许多。
上面的方法说完了,我们来看看put方法里的最后一个方法,addEntry:
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {//当size超过阀值时,对HashMap进行扩容,新的容量为原来的二倍
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);//扩容之后重新定位当前entry所在索引位置
}
createEntry(hash, key, value, bucketIndex);//把entry放到定位之后的位置
}
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));//将就数组内的元素放到扩容后的数组中!!!
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);//重新计算阀值
}
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {//遍历旧的table
while(null != e) {//将旧数组中每个索引位置上的所有键值对,放到新的数组上
Entry<K,V> next = e.next;//先保存下一次要处理的键值对
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);//计算当前entry在新数组中应在在的索引位置(这意味着,新数组中的键值对放置的位置与原数组是不用的)
e.next = newTable[i];//如果新数组对应索引位置没有数据,相当于把当前键值对的next置空,如果有数据,则当前键值对的next指向它。
newTable[i] = e;//定位的索引位置的数据改为当前键值对,相当于在新数组的当前索引的头部添加键值对
e = next;//遍历下一个键值对
}
}
}
单纯地文字描述,理解有点吃力,看看图:
我们假设旧数组长度为2,负载因子为1。因为扩容不涉及value,我们只用key表示键值对,旧的数组中有三个数据,key分别为3.5.7,hash()之后都应定位在table[1]上,所以内部结构为:
下面我们进行扩容:
1.新建一个table,长度为4,其中每个索引位置对应的数据都为null;即newtable[i]=null;
遍历oldtable;table[0]没有数据,table[1]中先从entry-3开始,所以上述代码中e为entry-3,next=e.next为entry-5;重新计算新数组中的索引位置,
int i = indexFor(e.hash, newCapacity);//3&(4-1)=3 ,所以存放在newtable[3]下,
e.next = newTable[i]; //newTable[3]为null,所以e.next=null;
![](https://i-blog.csdnimg.cn/blog_migrate/321d515010c5a3db517ac63cf3ca0ed1.png)
newTable[i] = e;//将当前键值对放到新数组定位的索引位置
![](https://i-blog.csdnimg.cn/blog_migrate/fc79634d445d002bf371063777b9950c.png)
e = next;//遍历下一个键值对
,第二次遍历,e为entry-5,对应的新的table中的存放位置应该是newtable[1];步骤和上述一样,结果为:
当遍历entry-7时,计算对应的新的table的存放位置为newtable[3],当前位置已经有了entry-3,所以
e.next = newTable[i];// newTable[3]为entry-3,所以e.next=entry-3
![](https://i-blog.csdnimg.cn/blog_migrate/ee253f4386293aad9905d2d6e64a7a68.png)
newTable[i] = e; //新数组索引3的位置替换为entry-7
至此,遍历结束:最终的内部结构就如上图所示,经过新旧数组对比,可以得到两点:
1.新旧数组中对应键值对的位置可能不同
2.还在同一索引位置的键值对顺序发生的倒转。(3-7变为7-3);
我们再来看看1.8中被优化的扩容(自己思考真的好麻烦,我借鉴网上大神的图和思路):
上面提到,因为数组的长度都是2的n次幂,所以新的数组中元素的位置要么是原位置,要么是原位置在移动2次幂的位置
示例,图(b)表示扩容后key1和key2两种key确定索引位置的示例,其中hash1是key1对应的哈希与高位运算结果。
元素在重新计算hash之后,因为n变为2倍,那么n-1的mask范围在高位多1bit(红色),因此新的index就会发生这样的变化:
因此,我们在扩充HashMap的时候,不需要像JDK1.7的实现那样重新计算hash,只需要看看原来的hash值新增的那个bit是1还是0就好了,是0的话索引没变,是1的话索引变成“原索引+oldCap”,可以看看下图为16扩充为32的resize示意图:
总体就是这样,想深究的去看看源码吧,好长,我就不在这摆摆了。
总之,1.8与1.7相比,性能得到了很大的优化,尤其是当数组中的链表较长时,红黑树大大提高了访问的效率。当然,HashMap是非线程安全的,所以,多线程情况下还是不推荐使用。就说这么多。