Android中須要瞭解的數據結構（三）
前言
MAP接口：算法
LinkedHashMap
LinkedHashMap繼承HashMap，全部HashMap中一些成員變量、方法LinkedHashMap中都是有的。數組
LinkedHashMap內部維護了一個雙向鏈表，解決了HashMap不能隨時保持遍歷順序和插入順序一致的問題。緩存
LinkedHashMap元素的訪問順序也提供了相關支持，也就是咱們常說的 LRU（最近最少使用）原則。安全
LinkedHashMap 擁有與 HashMap相同的底層哈希表結構，即數組+單鏈表+紅黑樹，也擁有相同的擴容機制。bash
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 指針維護插入鍵值對的順序。app
LinkedHashMap中put方法沒有重寫，所以和HashMap是同樣的，但也有不一樣，不一樣在於LinkedHashMap實現了afterNodeAccess，afterNodeInsertion方法 看HashMap put源碼ide
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()。
相關文章
- 1. Android中須要瞭解的數據結構（四）
- 2. Android中須要瞭解的數據結構（二）
- 3. Android中須要瞭解的數據結構（一）
- 4. Android中需要了解的數據結構（一）
- 5. Java中的數組數據結構需要了解的要點
- 6. Android中需要的數據結構
- 7. 數據結構三要素
- 8. Android中的數據結構
- 9. 爲何須要數據結構
- 10. 數據結構中棧一些須要注意的地方
- 更多相關文章...
- • Spring體系結構詳解 - Spring教程
- • Rust 結構體 - RUST 教程
- • Flink 數據傳輸及反壓詳解
- • TiDB 在摩拜單車在線數據業務的應用和實踐
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Android中須要瞭解的數據結構（四）
- 2. Android中須要瞭解的數據結構（二）
- 3. Android中須要瞭解的數據結構（一）
- 4. Android中需要了解的數據結構（一）
- 5. Java中的數組數據結構需要了解的要點
- 6. Android中需要的數據結構
- 7. 數據結構三要素
- 8. Android中的數據結構
- 9. 爲何須要數據結構
- 10. 數據結構中棧一些須要注意的地方