《java集合》–LinkedHashMap
說明:此文章基於jdk1.8
參考:LRU[【Java集合源碼剖析】LinkedHashmap源碼剖析](http://blog.csdn.net/ns_code/article/details/37867985)
簡介
LinkedHashMap是HashMap的子類,與HashMap有着同樣的存儲結構,同時又維護了一個雙線鏈表結構,將所有put到LinkedHashmap的節點一一串成了一個雙向循環鏈表,因此它保留了節點插入的順序,可以使節點的輸出順序與輸入順序相同。
LinkedHashMap可以用來實現LRU算法
數據結構
LinkedHashMap是HashMap的子類,與HashMap有相同的數據結構,同時爲了實現按照插入順序或者訪問順序進行迭代,LinkedHashMap內部維護了一個雙向鏈表結構。
基本屬性
transient LinkedHashMap.Entry head; 指向LinkedHashMap中雙向鏈表的首部指針
transient LinkedHashMap.Entry tail;指向LinkedHashMap中雙向鏈表的尾部指針
final boolean accessOrder;
1、true:按照訪問順序倒序排序,基於LRU算法(最少訪問算法),每次操作鏈表中的一個元素後,都將元素移除然後放到鏈表的最後,這樣保證最近訪問的放在最後,保證了最少訪問的元素最優先被遍歷訪問到。
2、false:按照插入順序排序
構造器
構造器調用了父類 HashMap 的相關構造方法來構造一個底層存放的 table 數組,需要初始長度和負載因子,同時比HashMap多了一個參數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;
}
添加元素
LinkedHashMap沒有覆寫HashMap中的put方法,而是覆寫了newNode方法
調用HashMap中的put方法(基於1.8)
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)
//新增一個節點,LinkedHashMap將同時向雙向鏈表尾部添加節點
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)
//新增一個節點,LinkedHashMap將同時向雙向鏈表尾部添加節點
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//新增一個節點,LinkedHashMap將同時向雙向鏈表尾部添加節點
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;
//如果對已存在的key進行覆蓋,則相當於訪問該key,LinkedHashMap操作雙向鏈表中的元素
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
LinkedList中覆寫了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;
}
//覆寫紅黑二叉樹node
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;
}
將新添加的元素添加到雙向鏈表的尾部
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;
}
}
當執行了get或者put已存在的key時,如果accessOrder是true,表示按照LRU算法,將本次訪問的元素移除並添加到雙向鏈表的最後
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
//判斷accessOrder
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中的節點比HashMap中的Entry多了雙向鏈表中 before和after指針
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);
}
}
刪除元素
LinkedHashMap 沒有覆寫HashMap中的remove方法,只是覆寫了remove方法的回調,來刪除雙向鏈表中的節點
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;
}
獲取元素
LinkedHashMap 根據key值獲取value時,調用的是父類HashMap中的get方法,在獲取完後,判斷accessOrder是否爲true,如果爲true,將本次訪問的節點從雙向鏈表中移除,然後添加到雙向鏈表的最後,保證LRU算法迭代訪問雙向鏈表
public V get(Object key) {
Node<K,V> e;
//調用父類HashMap中getNode方法
if ((e = getNode(hash(key), key)) == null)
return null;
//accessOrder若是true,按照LRU算法訪問雙向鏈表
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
public V getOrDefault(Object key, V defaultValue) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return defaultValue;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
遍歷LinkedHashMap
遍歷LinkedHashMap是訪問的雙向鏈表,保證了順序性
public void forEach(BiConsumer<? super K, ? super V> action) {
if (action == null)
throw new NullPointerException();
int mc = modCount;
for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
action.accept(e.key, e.value);
if (modCount != mc)
throw new ConcurrentModificationException();
}
迭代器操作是LinkedHashMap中的雙向鏈表
final class LinkedKeyIterator extends LinkedHashIterator
implements Iterator<K> {
public final K next() { return nextNode().getKey(); }
}
final class LinkedValueIterator extends LinkedHashIterator
implements Iterator<V> {
public final V next() { return nextNode().value; }
}
final class LinkedEntryIterator extends LinkedHashIterator
implements Iterator<Map.Entry<K,V>> {
public final Map.Entry<K,V> next() { return nextNode(); }
}
abstract class LinkedHashIterator {
LinkedHashMap.Entry<K,V> next;
LinkedHashMap.Entry<K,V> current;
int expectedModCount;
LinkedHashIterator() {
next = head;
expectedModCount = modCount;
current = null;
}
public final boolean hasNext() {
return next != null;
}
final LinkedHashMap.Entry<K,V> nextNode() {
LinkedHashMap.Entry<K,V> e = next;
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
current = e;
next = e.after;
return e;
}
public final void remove() {
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
removeNode(hash(key), key, null, false, false);
expectedModCount = modCount;
}
}
總結
LinkedHashMap是HashMap和LinkedList兩個集合類的存儲結構的結合。在LinkedHashMapMap中,所有put進來的Entry都跟HashMap一樣保存,但它又額外定義了一個雙向鏈表,每次put進來Entry,除了將其保存到對哈希表中對應的位置上外,還要將其插入到雙向循環鏈表的尾部。
LinkedHashMap由於繼承自HashMap,因此它具有HashMap的所有特性,同樣允許key和value爲null
LinkedHashMap不是線程安全的
accessOrder爲false時按照節點的插入順序排序;爲true按照訪問順序倒序排序LRU算法。
LinkedHashSet
LinkedHashSet 是對LinkedHashMap的簡單封裝,對LinkedHashSet的函數調用都會轉換成合適的LinkedHashMap方法。
public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, java.io.Serializable {
......
// LinkedHashSet裏面有一個LinkedHashMap
public LinkedHashSet(int initialCapacity, float loadFactor) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
......
public boolean add(E e) {//簡單的方法轉換
return map.put(e, PRESENT)==null;
}
......
}