前言
MAP介面：
LinkedHashMap
LinkedHashMap繼承HashMap，所有HashMap中一些成員變數、方法LinkedHashMap中都是有的。
LinkedHashMap內部維護了一個雙向連結串列，解決了HashMap不能隨時保持遍歷順序和插入順序一致的問題。
LinkedHashMap元素的訪問順序也提供了相關支援，也就是我們常說的 LRU（最近最少使用）原則。
LinkedHashMap 擁有與 HashMap相同的底層雜湊表結構，即陣列+單連結串列+紅黑樹，也擁有相同的擴容機制。
public class LinkedHashMap<K,V>extends HashMap<K,V>
implements Map<K,V>{
public LinkedHashMap() {
// 呼叫HashMap的構造方法，其實就是初始化Node<K,V>[] table
super();
// 這裡是指是否基於訪問排序，預設為false
accessOrder = false;
}
/**
* 雙向連結串列的頭部
*/
transient LinkedHashMap.Entry<K,V> head;
/**
* 雙向連結串列的尾部
*/
transient LinkedHashMap.Entry<K,V> tail;
/**
* 遍歷元素的順序，如果是true按照訪問順序，如果是false則按照插入順序
* @serial
*/
final boolean accessOrder;
}
複製程式碼基本跟HashMap一致，只是增加了一個accessOrder的屬性而已，該屬性預設false，即預設按照插入順序遍歷。
/**
* HashMap.Node subclass for normal LinkedHashMap entries.
*/
static class LinkedHashMapEntry<K,V> extends HashMap.Node<K,V> {
LinkedHashMapEntry<K,V> before, after;
LinkedHashMapEntry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
複製程式碼靜態內部類LinkedHashMapEntry繼承HashMap.Node<K,V>儲存鍵值對，用 before 與 next 指標維護插入鍵值對的順序。
LinkedHashMap中put方法沒有重寫，因此和HashMap是一樣的，但也有不同，不同在於LinkedHashMap實現了afterNodeAccess，afterNodeInsertion方法
看HashMap put原始碼
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); //這個方法HashMap是空實現，這裡是發生hash衝突後，找到有相同key對值進行處理時呼叫
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict); //這個方法HashMap也是空實現，這裡是完成新資料put後呼叫
return null;
}
複製程式碼可以看到每次新增新節點的時候實際上是呼叫 newNode 方法生成了一個新的節點，但是很明顯HashMap中的newNode方法沒有操作雙向連結串列節點的關係，所以LinkedHashMap複寫的該方法
//LinkedHashMap
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);
// 將 Entry 接在雙向連結串列的尾部
linkNodeLast(p);
return p;
}
// newNode 中新節點，放到雙向連結串列的尾部
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
// 新增元素之前雙向連結串列尾部節點
LinkedHashMap.Entry<K,V> last = tail;
// tail 指向新新增的節點
tail = p;
//如果之前 tail 指向 null 那麼集合為空新新增的節點 head = tail = p
if (last == null)
head = p;
else {
// 否則將新節點的 before 引用指向之前當前連結串列尾部
p.before = last;
// 當前連結串列尾部節點的 after 指向新節點
last.after = p;
}
}
//按需刪除最早插入的一個元素
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMapEntry<K,V> first;
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}
//通過afterNodeAccess方法維護訪問順序，每次訪問該元素就將該元素移動到雙向連結串列的末尾
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMapEntry<K,V> last;
if (accessOrder && (last = tail) != e) { //accessOrder用到了，如果是按照訪問元素順序遍歷並且當前節點不是尾節點，將該元素移到到最後一個
LinkedHashMapEntry<K,V> p =
(LinkedHashMapEntry<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 沒有重寫的 remove() 方法，使用的仍然是 HashMap 中的代 HashMap 中的 remove()方法：
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
//LinkedHashMap中實現
//從鏈式關係中刪除節點e
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 通過呼叫父類的 HashMap 的 remove 方法將 Hash 表的中節點的刪除操作完成，然後通過LinkedHashMap中的afterNodeRemoval()來維護連結串列。
同時發現上述的LinkedHashMap的實現中都會有accessOrder的判斷，這個就是用來維護訪問順序。
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
/**
* {@inheritDoc}
*/
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;
}
複製程式碼在我們的get方法中也會去呼叫afterNodeAccess(e),可以看出當我們使用 accessOrder 為 true 後，我們訪問元素會將它移到最後。
LRU
即近期最少使用，在Glide 的三級快取中記憶體快取中使用了這種快取策略，具體實現LruCache類。
LRU 演算法實現當達到設定閾值的時候，這個閾值可能是記憶體不足，或者容量達到最大，找到最近最少使用的儲存元素進行移除，保證新新增的元素能夠儲存到集合中。
public LruCache(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
//這裡指定了該集合的最大容量，一旦集合容量大於該容量則會呼叫trimToSize方法來減少容量。
this.maxSize = maxSize;
//這裡建立了LinkedHashMap並且第三個引數指定為true.該引數為true時LinkedHashMap開啟LRU演算法。
this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
}
複製程式碼從LruCache的建構函式中可以看到正是用了LinkedHashMap的訪問順序。
public final V put(K key, V value) {
//不可為空，否則丟擲異常
if (key == null || value == null) {
throw new NullPointerException("key == null || value == null");
}
V previous;
synchronized (this) {
//插入的快取物件值加1
putCount++;
//增加已有快取的大小
size += safeSizeOf(key, value);
//向map中加入快取物件
previous = map.put(key, value);
//如果已有快取物件，則快取大小恢復到之前
if (previous != null) {
size -= safeSizeOf(key, previous);
}
}
//entryRemoved()是個空方法，可以自行實現
if (previous != null) {
entryRemoved(false, key, previous, value);
}
//調整快取大小(關鍵方法)
trimToSize(maxSize);
return previous;
}
public void trimToSize(int maxSize) {
//死迴圈
while (true) {
K key;
V value;
synchronized (this) {
//如果map為空並且快取size不等於0或者快取size小於0，丟擲異常
if (size < 0 || (map.isEmpty() && size != 0)) {
throw new IllegalStateException(getClass().getName()
+ ".sizeOf() is reporting inconsistent results!");
}
//如果快取大小size小於最大快取，或者map為空，不需要再刪除快取物件，跳出迴圈
if (size <= maxSize || map.isEmpty()) {
break;
}
Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
key = toEvict.getKey();
value = toEvict.getValue();
//刪除該物件，並更新快取大小
map.remove(key);
size -= safeSizeOf(key, value);
evictionCount++;
}
//移除時會呼叫的回撥函式，本身沒有具體實現需要使用時要自己重寫
entryRemoved(true, key, value, null);
}
}
複製程式碼簡單來講就是每次存放新元素到集合中時間，會根據設定的maxSize來做判斷，若果高過的最大的size則會移除近期最少使用的元素。
HashMap、LinkedHashMap、TreeMap有什麼區別，應用場景是什麼？
- HashMap：基於HashMap.Node陣列加單向連結串列實現，非執行緒安全，地址不連續，查詢效率比較低，插入和刪除效率比較高，是無序的。適合插入和刪除操作頻繁的場景。
- LinkedHashMap：是一個維持雙向連結串列，可分為插入順序和訪問順序兩種，如果是訪問順序，那put和get操作已存在的Entry時，都會把Entry移動到雙向連結串列的表尾。
- TreeMap：基於紅黑樹實現，非執行緒安全，可以按照自然順序或者自定義順序自動排序，不允許插入null值，查詢效率比較高，適合需要排序的場景。
最後講一下迭代的方式選擇：
// for each map.entrySet()
Map<String, String> map = new HashMap<String, String>();
for (Entry<String, String> entry : map.entrySet()) {
entry.getKey();
entry.getValue();
}
//顯示呼叫map.entrySet()的集合迭代器
Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
entry.getKey();
entry.getValue();
}
// for each map.keySet()，再呼叫get獲取
Map<String, String> map = new HashMap<String, String>();
for (String key : map.keySet()) {
map.get(key);
}
// for each map.entrySet()，用臨時變數儲存map.entrySet()
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
entry.getKey();
entry.getValue();
}
複製程式碼 //keySet
private final class KeyIterator extends HashIterator<K> {
public K next() {
return nextEntry().getKey();
}
}
//entrySet
private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}
複製程式碼keySet()和entrySet()返回的set的迭代器，從中我們可以看到只是返回值不同而已，父類相同，所以效能相差不多。只是第三種方式多了一步根據key,get得到value的操作而已。 所以需要key以及value的情況下選擇和entrySet()。