概要:
LinkedHashMap继承HashMap,但是添加了双向链表来保存元素的顺序。LinkedHashMap重写了三个回调方法和两个newNode方法来处理双向链表的添加和修改。
// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) { }
TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) { }
具体的实现是:
①添加元素: LinkedHashMap没有自己的put方法,用的是HashMap的put方法,但是有三个自己的处理
●通过重写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);
return p;
}
TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
linkNodeLast(p);
return p;
}
// link at the end of list
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;
tail = p;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
}
●通过重写afterNodeInsertion方法(需要我们自己去重写removeEldestEntry方法)来实现双向链表的head的删除。
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
●如果put时,key在map中存在,则会调用重写的afterNodeAccess来把更新的元素放到双向链表的最后(参照下面的③)
②删除元素:和put一样,用的是HashMap的remove方法,但是重写了afterNodeRemoval方法,来实现双向链表的元素的删除
void afterNodeRemoval(Node<K,V> e) { // unlink
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
p.before = p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a == null)
tail = b;
else
a.before = b;
}
③取得元素,重写了get方法,说是重写其实只是加了一点处理,那为什么不能像put和remove一个用一个回调方法来解决呢?其实是因为LinkedHashMap中追加了一个accessOrder的成员变量(false:插入的顺序,ture:访问的顺序),只有在accessOrder为true时才会进行处理(把要get的元素放到双向链表的最后)。
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null) //HashMap里就是只用了这一步
return null;
if (accessOrder) // accessOrder为true,表示访问的顺序
afterNodeAccess(e);
return e.value;
}
HashMap的get
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : 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;
}
}
➡LinkedHashMap的底层数据结构
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after; // 新添加的,用来保存前后节点
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
/**
* The head (eldest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> head;
/**
* The tail (youngest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> tail;
/**
* The iteration ordering method for this linked hash map: <tt>true</tt>
* for access-order, <tt>false</tt> for insertion-order.
*
* @serial
*/
final boolean accessOrder; // true:访问顺序(包含get方法,put已存在key的情况) false:默认的,插入顺序(不包含get方法和put已存在key的情况)
构造方法
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
public LinkedHashMap() {
super();
accessOrder = false;
}
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}