摘要
HashMap可以说是在程序开发中使用最频繁的映射处理的数据类型。在JDK1.8中又对HashMap进行了优化,引入了红黑树的数据结构和扩容的优化。接下来就探讨一下HashMap的结构和实现原理。
简介
Java中的映射类容器都是继承自java.util.Map接口,Map接口主要有四个实现类,它们分别是:HashMap、LinkedHashMap、TreeMap和Hashtable。它们之间的继承关系如下图:
实现类的简单比较:
- HashMap:Map基于散列表的实现。它根据键的hashCode值存储和查找数据。但是遍历的顺序不固定。在HashMap中只允许存储一条键为null的数据。HashMap时线程不安全的,当多个线程同时操作一个HashMap时,可能造成数据不一致。
- HashTable:很多映射操作与HashMap相似。但是HashTable继承自Dictionary类,而且HashTable时线程安全的,不过并发性不如ConcurrentHashMap。在不予要并发的场景应该使用HashMap。
- LinkedHashMap:类似于HashMap,是HashMap的子类。但是遍历它时,取得键值对的顺序是插入时的顺序,或者是最近最少使用(LRU)的顺序。比HashMap慢一点,但在迭代访问时比较快,因为它使用链表维护内部次序。
- TreeMap:TreeMap实现SortedMap接口,能够把它保存的记录根据键排序,默认是按键值的升序排序,也可以指定排序的比较器,当用Iterator遍历TreeMap时,得到的记录是排过序的。如果使用排序的映射,建议使用TreeMap。在使用TreeMap时,key必须实现Comparable接口或者在构造TreeMap传入自定义的Comparator,否则会在运行时抛出java.lang.ClassCastException类型的异常。
HashMap的内部实现
HashMap通过数组+链表+红黑树(JDK1.8引入了红黑树)的结构来存储数据。从源码中可知,HashMap中有一个内部类Node
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //键的hash值,用来定位索引
final K key;
V value;
Node<K,V> next; //下一个节点,用于碰撞存储
Node(int hash, K key, V value, Node<K,V> next) {...}
public final K getKey() { ...}
public final V getValue() { ... }
public final String toString() { ... }
public final int hashCode() {...}
public final V setValue(V newValue) {...}
public final boolean equals(Object o) {...}
}
在HashMap中就是以Node类为基本存储单元。同时HashMap中有一个重要的字段Node[] table,这个数组类就是哈希桶,HashMap中的元素都存储在哈希桶中。哈希桶在HashMap中解决了元素碰撞问题,当存储元素时通过计算键(key)的hash值来获得元素的索引。如果在哈希桶中原来的位置已经存在元素说明发生了碰撞,那么将元素的放在对应索引的链表中。
通过源码,我们还可以看到一个属性loadFactor(负载因子),它有个默认值是DEFAULT_LOAD_FACTOR = 0.75f;这个属性是HashMap扩容机制的重要参数,当HashMap中元素的数量大于等于length乘于loadFactor时就进行扩容。扩容之后HashMap的容量是之前的两倍。
当loadFactor比较大时,那么HashMap再下一次扩容前能够存储更多的元素。而当loadFactor比较小时,HashMap在下次扩容前就只能存储更少的元素。综上,loadFactor的意义就是对时间和空间的一个衡量。不过我们在使用HashMap的时候使用默认值就可以满足大多数情况,不用刻意更改loadFactor。
HashMap的功能实现
1.确定元素在哈希桶的索引位置
HashMap操作元素时,第一步就是确定元素的索引。在HashMap中通过hash算法将元素分散到哈希桶中,所以hash算法的好坏对元素的分布有着很大的影响。以下是JDK1.8中hash算法的实现。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); //将键(key)的hash值充分计算
}
(length - 1) & hash //确定索引的最后一步,相当于和容器长度做与操作
从源码中可知,hash算法可以分为三步:计算key的hashcode,高位与运算(即右移,高位补0),异或运算。最后得到索引时还需要与(length-1)进行&操作。
那么(length - 1) & hash为什么相当于取模运算呢?我们知道HashMap中容器的长度都是2的n次方,当进行length-1运算时,除了最高位变0,其他位都变1。而对长度取模相当于(计算后得到的)hash值向右移动n位后移出的那个值(即hash值的右边n位的值),而这个值就等于(length - 1) & hash。
2.HashMap中的put方法
1) 首先判断哈希桶数组table是否为null或者table的长度为0 ,如果条件成立则执行扩容方法(resize);
2) 根据key(键)计算hash得到插入数组的索引。如果当前位置的节点为null,直接插入。否则转向第3步;
3) 判断哈希桶数组table[i]的首个元素的key是否与插入元素的key相等(通过hashcode和equals判断),如果相等,则替换value(值)。如果不相等,转向4;
4) 判断当前table[i]是否是红黑树,如果是,直接在红黑树中插入value(值)。否则转向5;
5) 遍历table[i]的链表,如果下个元素时null,则插入到下个元素,然后判断链表长度是否大于8,将链表转化为红黑树。在遍历过程中,如果发现key已经存在,直接覆盖value即可;
6)插入成功后,判断总的键值对数量size是否超过了最大容量threshold,如果超过,进行扩容。
public V put(K key, V value) {
//计算键的hashCode值
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//步骤1:table为null则创建table
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; //table为null,执行resize()方法
//步骤2:当前索引下元素为null,直接插入
//计算索引
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//步骤3:节点存在,直接覆盖。覆盖逻辑在下面执行
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//步骤4:判断时候为红黑树结构
else if (p instanceof TreeNode)
//将元素插入红黑树
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//步骤5:将元素出入链表
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//链表长度大于8时转化为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//节点已存在,则覆盖
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//这里的逻辑就是覆盖已存在节点的逻辑
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//步骤6:扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
3.扩容机制
当HashMap中元素的数量大于threshold(可存储容量)时就会进行扩容。在JDK1.8中对扩容机制进行了一些优化。开始扩容时容量会扩大到原来的两倍,所以当转移元素到新的哈希桶时,重新计算(e.hash & oldCap)后,如果值为0,就将元素放到原来的位置,否则放到(原来位置+oldCap)。因为在HashMap容量变为原来的2倍后,所以,元素的位置要么是在原位置,要么是在原位置再移动2次幂的位置。这里是在Java8中做的一个优化。比如:如果使用上文将的hash算法去寻址,那么会得到这样的结果,在哈希桶的长读扩大为原来的2倍时,length-1的结果中2进制的表示也多了一位1。于是hash & (length-1)的结果在与多出的一位进行&操作时,结果要么是1,要么是0。为1的时候就是加上原来的长度oldLen,为0的时候位置不变。
下面讲到的扩容机制中也会采用这个原理进行优化。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//当大于最大容量时,就不在进行扩容了
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//否则进行扩容,容量增大到原来的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//计算新的上限
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//将每个元素移动到新的哈希桶中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
//直接复制
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//插入到红黑树中
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null; //低位元素,即原来的位置
Node<K,V> hiHead = null, hiTail = null; //高位元素,即原来位置+oldCap
Node<K,V> next;
do {
next = e.next;
//计算是否为0或者1
if ((e.hash & oldCap) == 0) {
//为0,放入原来的位置
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
//为1,放入原来位置+oldCap
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
//放入原来的位置
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
//放入原来位置+oldCap
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
总结
HashMap使用的一些建议
(1) 扩容是一个特别耗性能的操作,所以当程序员在使用HashMap的时候,估算map的大小,初始化的时候给一个大致的数值,避免map进行频繁的扩容。
(2) 负载因子是可以修改的,也可以大于1,但是建议不要轻易修改,除非情况非常特殊。
(3) HashMap是线程不安全的,不要在并发的环境中同时操作HashMap,建议使用ConcurrentHashMap。
(4) JDK1.8引入红黑树大程度优化了HashMap的性能。