写在前面:
Java为了更方便的使用数据结构中的映射机制,提供了Java.util.Map接口,Map接口有4个常用的实现类:HashMap、LinkedHashMap、HashTable、TreeMap。在这篇博客中,我们将分实现原理。。。来对JDK8下的HashMap源码分析。
Java集合框架关系图:
Map的4个实现类对比:
(1)HashMap:HashMap保存了一个键值对,即一个key对应唯一一个value。HashMap在大多数情况下,可以迅速的定位到key所对应的值,但是HashMap的遍历是无序的。HashMap只允许一个key为null,允许多个value为null。HashMap是非线程安全的,并发访问资源时,可以使用ConcurrentHashMap来替代。
(2)HashTable:与HashMap类似,但是是线程安全的,在同一时刻,只能有一个线程访问HashTablen内的资源,但是这样做却牺牲了效率,与HashMap一样,可以使用ConcurrentHashMap来替代。
(3)LinkedHashMap:HashMap的子类,保存了记录的插入顺序,在用Iterator遍历的时候,先得到的记录肯定是先插入的。
(4)TreeMap:实现SortedMap接口,能够将保存的顺序,根据键值升序,或者指定比较器排序。在用Iterator遍历的时候,得到的就是排序过的键值对。
HashMap结构:
我们都知道,数组的查找效率很高,但是插入和删除的效率不是很好。而链表只需要改变节点的指向,就可以很好的解决数组的插入和删除问题。为了结合数组和链表的特性,我们要找到一种寻址容易,且插入删除也容易的数据结构---哈希表。
哈希表有多种实现方式入开放地址法,链地址法,在Java中采用链地址法,也就是说Java中HashMap是数组+链表+红黑树的组合实现。链地址法很好的解决了Hash冲突,那么什么是Hash冲突呢?在put方法实现时,我们需要根据Key值找到对应的数组索引,在这个数组索引的位置插入键值对。但是由于不同的Key值在散列函数的计算之后,可能会得到相同的索引,这就发生了Hash冲突,也成为Hash碰撞。而一个优秀的Hash函数会尽量避免Hash冲突。
接下来,我们通过源码分别来看HashMap的底层存储机制:
- HashMap-put方法源码:
public V put(K key, V value) {
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;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
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;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
- put方法实现过程:
(1)令tab=table数组,判断数组tab是否为null,或者长度是否为0?如果不为空或不为0,则创建一个数组,否则resize().
(2)在一个长度为16的数组中,数组中的元素存储的是链表的头结点,那么第二步就是确定数组索引,索引i=(n-1)&hash,hash则是我们通过hash方法对键key的计算结果。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
hash算法会对传入的key求hashcode(),然后进行无符号右移运算,最后进行按位异或运算。
如果tab[i]=null,则创建一个结点并添加转向(6)。如果不为null,则进入else,转向(3)。
(3)判断tab[i]的首个元素是否和key一样,如果一样,则直接覆盖value。如果不相同,转向(4)。
(4)判断tab[i]是否为红黑树,如果是,则直接在树中插入键值对,否则转向(5)。
(5)遍历tab[I],判断链表长度是否>8,如果>8,则转为红黑树,在红黑树中执行插入操作,否则就执行链表的插入操作。
(6)插入成功后,判断实际存在的键值对是否>threshod,如果大于则扩容。
注:我们之前说过,HashMap是采用拉链式存储,即数组+链表+红黑树,例如:传入一个键值对A,key=1,对应的value=“abc”,如果计算key的hash值=0,那么tab[0]=键值对A,又传入一个键值对B,key=2,对应的value=“def”,那么假如key=2的hash值也=0,首先判断,键值对B的索引tab[0]上存放的首个元素的Key是否=传入的Key,显然1不等于2,那么我们就要判断是否为红黑树,如果是红黑树,那么在树中插入键值对B,如果不是红黑树,那么tab[0]存放的链表头部插入键值对B。
这样做之后,也会始终保证,tab[i]的头节点,是最新插入的键值对,且不重复。
------------------------------------------------------------------------
- 为什么HashMap的大小是2的次幂?
我们看到putval方法中的第四行,p=tab[i=(n-1)&h],这句代码,n为HashMap为数组初始化的长度,h是key经过hash方法计算出来的值,h再经过(n-1)的位与运算,来找到数组的索引位置。
那这与2的次幂有什么关系呢?因为当我们的n=2的次幂时,(n-1)&h=h%n,但是因为位运算的效率更高,所以我们只要保证输入为2的次幂,或者经过处理之后为2的次幂,第一让我们分配数组索引更合理,尽量避免了Hash冲突第二点就是位运算使得算法效率更高。
此外,接下来的resize方法中,我们每次也都是将容量扩大为原来的2倍。
------------------------------------------------------------------------
- HashMap提供的字段:
在HashMap提供的字段中,我们可以看到HashMap默认初始化的容量为16,加载因子为0.75,而threshold是下次扩容的临界值=capacity*loadFactor。也就是在默认情况下,当元素到达12的时候,就会扩容,并且容量为16的2倍,即32。
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//默认初始化容量为1<<4=16
static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量为2的30次方
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认加载因为=0.75
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
transient Node<K, V>[] table;//存放链表的数组
transient Set<Map.Entry<K, V>> entrySet;
transient int size;//已存元素的个数
transient int modCount;
int threshold;//表示下次扩容的临界值,当size>=threshold时,扩容
final float loadFactor;//加载因子
- 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;
this.threshold = tableSizeFor(initialCapacity);
}
HashMap提供了4个构造方法,但是最终都会调用上面的构造方法。
- HashMap-resize方法源码:
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;
}
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;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
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;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}