LinkedHashMap与HashMap的区别
- LinkedHashMap与HashMap主要的区别在于,LinkedHashMap可以按照访问或者插入数据的顺序遍历元素,而HashMap是散列存储和读取数据,还有一个特性值可以配置一个参数实现删除比较老旧的头结点,这个特性可以在缓存方面使用,在添加元素的时候,可以把当前在双向量表的表头数据删除掉。
LinkedHashMap类继承关系
- 继承自HashMap, 实现了map接口
3个实例变量
-
transient LinkedHashMap.Entry<K,V> head;
使用transient关键字,说明这个字段不用会被序列化到流中。双向链表的表头,在双向链表中的每个节点都是Entry,这个实体在后面在了解。 -
transient LinkedHashMap.Entry<K,V> tail;
双向链表的尾部 -
final boolean accessOrder;
是否按照访问顺序遍历,如何设置成true,那在每次get后会把get的那个节点从双向列表中移到表尾,初始化创建实例是指定,一旦指定就可可更改,因为用的是final 关键字。如果设置成false,则get后和HashMap就一样啦。 -
有5种构造方法
构造方法的本质就是调用父类HashMap的构造方法,不同的是在调用父类构造方法后,完成accessOrder的初始化默认是false,可以通过构造方法设置这个值。其中构造方法可以实现将一个实现Map接口的集合作为参数整合到创建的LinkedHashMap中。
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
既然LinkedHashMap可以实现按照访问的顺序或者插入的顺序遍历列表,就要知道这个特性的实现原理是什么才行。
先看看LinkedHashMap是如何put的,LinkedHashMap并没有实现自己的put的方法,而是在父类的putval添加了处理,看代码
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);// 这个地方很重要,LinkedHashMap重写了 newNode ,将插入的元素添加到链表表尾,完成双向的绑定。
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);// e 元素表示put操作后返回的旧元素,这种覆盖旧值的情况下也在访问后移动的双向链表的表尾。
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);// 这几话的意思是将put的元素移动到双向链表的表尾,同时这个方法中还可以指定是否删除双向链表的表头数据。
return null;
}
来看看newNode
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
LinkedHashMap.Entry<K,V> p =
new LinkedHashMap.Entry<K,V>(hash, key, value, e);
linkNodeLast(p);// 主要是这个方法,linkNodeLast将当前节点连接到表尾
return p;
}
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;// 像这种链表操作经常用到临时变量,起到中间变换的作用
tail = p;// 把当前节点设置成尾节点
if (last == null)// 表尾元素为空说明双向链表为空,直接将当前节点设置成head
head = p;
else {// 双向链表最常用的套路
p.before = last;
last.after = p;
}
}
来看看afterNodeInsertion
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
if (evict && (first = head) != null && removeEldestEntry(first)) {// 这个removeEldestEntry 默认是false,需要继承LinkedHashMap重写这个方法才可以使用。
K key = first.key;
removeNode(hash(key), key, null, false, true);// 将老旧的头结点删除掉
}
}
public V get(Object key) { // 重写了父类的get方法
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)// 这里和父类的是一样的
return null;
if (accessOrder)
afterNodeAccess(e);// 不同的地方,当按照访问顺序遍历时,做处理
return e.value;
}
看下是如何实现将访问过的元素放在双向链表的表尾的
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
if (accessOrder && (last = tail) != e) {
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a != null)
a.before = b;
else
last = b;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
tail = p;
++modCount;
}
}
这里画张图更好,灵魂画手开始。。。
当前节点的前后节点的其他位置情况看代码类推即可。
- 性能上的差异
但是这里有一个需要思考的问题,因为hashMap的操作的效率高的原因是应为每个桶是单链表,根据hash(key) &(n-1)的值获取数组中的第一个节点,这个节点是哈希桶的节点,然后遍历这个桶根据,key的hash值、key的equals比较寻找元素是否重复。但是LinkedHashMap每个Entry的next链接的是下一个插入的元素,那么如果两个hash值相同的key,中插入了很多元素的话,那找到下一个元素的时间就要比HashMap要多些。