前言：這一篇 LinkedHashMap 和 之前的一篇 HashMap 大部分都是來源簡書的藝術家的相關文章，寫的非常好，就拿來學習了，
發現這里的源碼和 Java 8 的不一樣，不知道具體是哪個版本，沒有去研究，之后還會再寫兩篇基于 Java 8 的LinkedHashMap 和 HashMap 的 源碼解析。
1. LinkedHashMap 使用與實現
1.1 應用場景
HashMap 是無序的，HashMap 在 put 的時候是根據 key 的 hashcode 進行 hash 然后放入對應的地方。
所以在按照一定順序 put 進 HashMap 中，然后遍歷出 HashMap 的順序跟 put 的順序不同（除非在 put 的時候 key 已經按照 hashcode 排序號了，這種幾率非常小）。
當我們希望有順序地去存儲 key-value 時，就需要使用 LinkedHashMap 了。
1.2 繼承
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>
{
LinkedHashMap 繼承了 HashMap，所以它們有很多相似的地方。
1.3 構造方法
LinkedHashMap 提供了五個構造方法，我們先看空參的構造方法。
/**
* Constructs an empty insertion-ordered <tt>LinkedHashMap</tt> instance
* with the default initial capacity (16) and load factor (0.75).
*/
public LinkedHashMap() {
// 調用 HashMap 的構造方法，其實就是初始化 Entry[] table
super();
// 這里是指是否基于訪問排序，默認為 false 為插入順序
accessOrder = false;
}
首先使用 super 調用了父類 HashMap 的構造方法，其實就是根據初始容量、負載因子去初始化 Entry[] table。
然后把 accessOrder 設置為 false，這就跟存儲的順序有關了，LinkedHashMap 存儲數據是有序的，而且分為兩種：插入順序和訪問順序。
這里 accessOrder 設置為 false，表示不是訪問順序而是插入順序存儲的，這也是默認值，表示 LinkedHashMap 中存儲的順序是按照調用 put 方法插入的順序進行排序的。
LinkedHashMap 也提供了可以設置 accessOrder 的構造方法，我們來看看這種模式下，它的順序有什么特點？
LinkedHashMap<Object, Object> linkedHashMap = new LinkedHashMap<>(128, (float) 0.75, true);
linkedHashMap.put("key1", "value");
linkedHashMap.put("key2", "value");
linkedHashMap.put("key3", "value");
Set<Map.Entry<Object, Object>> entrySet = linkedHashMap.entrySet();
Iterator<Map.Entry<Object, Object>> iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry<Object, Object> next = iterator.next();
Log.d("JunL", "key = " + next.getKey() + " --- value = " + next.getValue());
}
Object key1 = linkedHashMap.get("key1");
Set<Map.Entry<Object, Object>> entrySet2 = linkedHashMap.entrySet();
Iterator<Map.Entry<Object, Object>> iterator2 = entrySet2.iterator();
while (iterator2.hasNext()) {
Map.Entry<Object, Object> next = iterator2.next();
Log.d("JunL", "key = " + next.getKey() + " --- value = " + next.getValue());
}
因為調用了 get("name1") 導致了 name1 對應的 Entry 移動到了最后。
再來看一下 LinkedHashMap 的 init 方法：
/**
* Called by superclass constructors and pseudoconstructors (clone,
* readObject) before any entries are inserted into the map. Initializes
* the chain.
*/
@Override
void init() {
// 創建了一個 hash = -1，key、value、next 都為 null 的 Entry
header = new Entry<>(-1, null, null, null);
// 讓創建的 Entry 的 before 和 afte r都指向自身，注意 after 不是之前提到的 next
// 其實就是創建了一個只有頭部節點的雙向鏈表
header.before = header.after = header;
}
這好像跟 HashMap 提到的 Entry 有些不一樣，HashMap 中靜態內部類 Entry 是這樣定義的：
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
LinkedHashMap 有自己的靜態內部類 Entry，它繼承了 HashMap.Entry，定義如下:
/**
* HashMap.Node subclass for normal LinkedHashMap entries.
*/
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 構造函數初始化了一個 Entry[] table，然后調用自身的 init 初始化了一個只有頭結點的雙向鏈表。完成了如下操作:
1.4 put 方法
LinkedHashMap 沒有重寫 put 方法，所以還是調用 HashMap 得到 put 方法，如下：
public V put(K key, V value) {
// 對key為null的處理
if (key == null)
return putForNullKey(value);
// 計算hash
int hash = hash(key);
// 得到在table中的index
int i = indexFor(hash, table.length);
// 遍歷table[index]，是否key已經存在，存在則替換，并返回舊值
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
// 如果key之前在table中不存在，則調用addEntry，LinkedHashMap重寫了該方法
addEntry(hash, key, value, i);
return null;
}
LinkedHashMap的addEntry方法：
void addEntry(int hash, K key, V value, int bucketIndex) {
// 調用父類的 addEntry，增加一個 Entry 到 HashMap 中
super.addEntry(hash, key, value, bucketIndex);
// removeEldestEntry 方法默認返回 false，不用考慮
Entry<K,V> eldest = header.after;
if (removeEldestEntry(eldest)) {
removeEntryForKey(eldest.key);
}
}
這里調用了父類 HashMap 的 addEntry 方法，如下：
void addEntry(int hash, K key, V value, int bucketIndex) {
// 擴容相關
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
// LinkedHashMap 進行了重寫
createEntry(hash, key, value, bucketIndex);
}
這里主要看createEntry方法，LinkedHashMap進行了重寫。
void createEntry(int hash, K key, V value, int bucketIndex) {
HashMap.Entry<K,V> old = table[bucketIndex];
// e就是新創建了Entry，會加入到table[bucketIndex]的表頭
Entry<K,V> e = new Entry<>(hash, key, value, old);
table[bucketIndex] = e;
// 把新創建的Entry，加入到雙向鏈表中
e.addBefore(header);
size++;
}
我們來看看 LinkedHashMap.Entry 的 addBefore 方法：
private void addBefore(Entry<K,V> existingEntry) {
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}
從這里就可以看出，當 put 元素時，不但要把它加入到 HashMap 中去，還要加入到雙向鏈表中，所以可以看出 LinkedHashMap 就是 HashMap+ 雙向鏈表，下面用圖來表示逐步往 LinkedHashMap 中添加數據的過程，紅色部分是雙向鏈表，黑色部分是 HashMap 結構，header 是一個 Entry 類型的雙向鏈表表頭，本身不存儲數據。
首先是只加入一個元素 Entry1，假設 index 為 0：
當再加入一個元素 Entry2，假設 index 為 15：
當再加入一個元素 Entry3, 假設 index 也是 0：
以上，就是 LinkedHashMap 的 put 的所有過程了，總體來看，跟 HashMap 的 put 類似，只不過多了把新增的 Entry 加入到雙向列表中。
1.5 擴容
在 HashMap 的 put 方法中，如果發現前元素個數超過了擴容閥值時，會調用 resize 方法，如下：
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
boolean oldAltHashing = useAltHashing;
useAltHashing |= sun.misc.VM.isBooted() &&
(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean rehash = oldAltHashing ^ useAltHashing;
// 把舊table的數據遷移到新table
transfer(newTable, rehash);
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
LinkedHashMap 重寫了 transfer 方法，數據的遷移，它的實現如下：
void transfer(HashMap.Entry[] newTable, boolean rehash) {
// 擴容后的容量是之前的2倍
int newCapacity = newTable.length;
// 遍歷雙向鏈表，把所有雙向鏈表中的Entry，重新就算hash，并加入到新的table中
for (Entry<K,V> e = header.after; e != header; e = e.after) {
if (rehash)
e.hash = (e.key == null) ? 0 : hash(e.key);
int index = indexFor(e.hash, newCapacity);
e.next = newTable[index];
newTable[index] = e;
}
}
可以看出，LinkedHashMap 擴容時，數據的再散列和 HashMap 是不一樣的。
HashMap 是先遍歷舊 table，再遍歷舊 table 中每個元素的單向鏈表，取得 Entry 以后，重新計算 hash 值，然后存放到新 table 的對應位置。
LinkedHashMap 是遍歷的雙向鏈表，取得每一個 Entry，然后重新計算 hash 值，然后存放到新 table 的對應位置。
從遍歷的效率來說，遍歷雙向鏈表的效率要高于遍歷 table，因為遍歷雙向鏈表是 N 次（N為元素個數）；而遍歷 table 是 N + table 的空余個數（N為元素個數）。
1.6 雙向鏈表的重排序
前面分析的，主要是當前 LinkedHashMap 中不存在當前 key 時，新增 Entry 的情況。當 key 如果已經存在時，則進行更新 Entry 的 value。就是 HashMap 的 put 方法中的如下代碼：
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
// 重排序
e.recordAccess(this);
return oldValue;
}
}
主要看 e.recordAccess(this)，這個方法跟訪問順序有關，而 HashMap 是無序的，所以在 HashMap.Entry 的 recordAccess 方法是空實現，但是 LinkedHashMap 是有序的，LinkedHashMap.Entry 對 recordAccess 方法進行了重寫。
void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
// 如果LinkedHashMap的accessOrder為true，則進行重排序
// 比如前面提到LruCache中使用到的LinkedHashMap的accessOrder屬性就為true
if (lm.accessOrder) {
lm.modCount++;
// 把更新的Entry從雙向鏈表中移除
remove();
// 再把更新的Entry加入到雙向鏈表的表尾
addBefore(lm.header);
}
}
在 LinkedHashMap 中，只有 accessOrder 為 true，即是訪問順序模式，才會 put 時對更新的 Entry 進行重新排序，而如果是插入順序模式時，不會重新排序，這里的排序跟在 HashMap 中存儲沒有關系，只是指在雙向鏈表中的順序。
舉個栗子：開始時，HashMap 中有 Entry1、Entry2、Entry3，并設置 LinkedHashMap 為訪問順序，則更新 Entry1 時，會先把 Entry1 從雙向鏈表中刪除，然后再把 Entry1 加入到雙向鏈表的表尾，而 Entry1 在 HashMap 結構中的存儲位置沒有變化，對比圖如下所示：
可以看到，header 的 after 指向了 Entry 2，before 指向的 Entry 1；
1.7 get 方法
LinkedHashMap 有對 get 方法進行了重寫，如下：
public V get(Object key) {
// 調用 getEntry 得到 Entry
Entry<K,V> e = (Entry<K,V>)getEntry(key);
if (e == null)
return null;
// 如果 LinkedHashMap 是訪問順序的，則 get 時，也需要重新排序
e.recordAccess(this);
return e.value;
}
先是調用了 getEntry 方法，通過 key 得到 Entry，而LinkedHashMap 并沒有重寫 getEntry 方法，所以調用的是 HashMap的 getEntry 方法。
在分析過 HashMap 的 getEntry 方法：首先通過 key 算出 hash 值，然后根據 hash 值算出在 table 中存儲的 index，然后遍歷 table[index] 的單向鏈表去對比 key，如果找到了就返回 Entry。
后面調用了 LinkedHashMap.Entry 的 recordAccess 方法，上面分析過 put 過程中這個方法，其實就是在訪問順序的 LinkedHashMap 進行了 get 操作以后，重新排序，把 get 的 Entry 移動到雙向鏈表的表尾。
1.8 遍歷方式取數據
我們先來看看HashMap使用遍歷方式取數據的過程：
很明顯，這樣取出來的 Entry 順序肯定跟插入順序不同了，既然 LinkedHashMap 是有序的，那么它是怎么實現的呢？
先看看 LinkedHashMap 取遍歷方式獲取數據的代碼：
Map<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("name1", "josan1");
linkedHashMap.put("name2", "josan2");
linkedHashMap.put("name3", "josan3");
// LinkedHashMap沒有重寫該方法，調用的HashMap中的entrySet方法
Set<Entry<String, String>> set = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext()) {
Entry entry = iterator.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
}
LinkedHashMap 沒有重寫 entrySet 方法，我們先來看 HashMap 中的 entrySet，如下：
public Set<Map.Entry<K,V>> entrySet() {
return entrySet0();
}
private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return newEntryIterator();
}
// 無關代碼
......
}
可以看到，HashMap 的 entrySet 方法，其實就是返回了一個 EntrySet 對象。
我們得到 EntrySet 會調用它的 iterator 方法去得到迭代器 Iterator，從上面的代碼也可以看到，iterator 方法中直接調用了* newEntryIterator 方法并返回，而 LinkedHashMap 重寫了該方法
Iterator<Map.Entry<K,V>> newEntryIterator() {
return new EntryIterator();
}
這里直接返回了 EntryIterator 對象，這個和 HashMap 中的 newEntryIterator 方法中一模一樣，都是返回了 EntryIterator 對象，其實他們返回的是各自的內部類。我們來看看 LinkedHashMap 中 EntryIterator 的定義：
private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}
該類是繼承 LinkedHashIterator，并重寫了 next 方法；而 HashMap 中是繼承 HashIterator。
我們再來看看 LinkedHashIterator 的定義：
private abstract class LinkedHashIterator<T> implements Iterator<T> {
// 默認下一個返回的Entry為雙向鏈表表頭的下一個元素
Entry<K,V> nextEntry = header.after;
Entry<K,V> lastReturned = null;
public boolean hasNext() {
return nextEntry != header;
}
Entry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (nextEntry == header)
throw new NoSuchElementException();
Entry<K,V> e = lastReturned = nextEntry;
nextEntry = e.after;
return e;
}
// 不相關代碼
......
}
我們先不看整個類的實現，只要知道在 LinkedHashMap 中，
Iterator<Entry<String, String>> iterator = set.iterator();
這段代碼會返回一個繼承 LinkedHashIterator 的 Iterator，它有著跟 HashIterator 不一樣的遍歷規則。
接著，我們會用 while(iterator.hasNext()) 去循環判斷是否有下一個元素，LinkedHashMap 中的 EntryIterator 沒有重寫該方法，所以還是調用 LinkedHashIterator 中的 hasNext 方法，如下：
public boolean hasNext() {
// 下一個應該返回的Entry是否就是雙向鏈表的頭結點
// 有兩種情況：1.LinkedHashMap中沒有元素；2.遍歷完雙向鏈表回到頭部
return nextEntry != header;
}
nextEntry 表示下一個應該返回的 Entry，默認值是 header.after，即雙向鏈表表頭的下一個元素。
而上面介紹到，LinkedHashMap 在初始化時，會調用 init 方法去初始化一個 before 和 after 都指向自身的 Entry，但是 put 過程會把新增加的 Entry 加入到雙向鏈表的表尾，所以只要 LinkedHashMap 中有元素，第一次調用 hasNext 肯定不會為 false。
然后我們會調用 next 方法去取出 Entry，LinkedHashMap 中的 EntryIterator 重寫了該方法，如下：
public Map.Entry<K,V> next() {
return nextEntry();
}
而它自身又沒有重寫 nextEntry 方法，所以還是調用的 LinkedHashIterator 中的 nextEntry 方法：
Entry<K,V> nextEntry() {
// 保存應該返回的 Entry
Entry<K,V> e = lastReturned = nextEntry;
//把當前應該返回的 Entry 的 after 作為下一個應該返回的 Entry
nextEntry = e.after;
// 返回當前應該返回的 Entry
return e;
}
這里其實遍歷的是雙向鏈表，所以不會存在 HashMap 中需要尋找下一條單向鏈表的情況，從頭結點 Entry header 的下一個節點開始，只要把當前返回的 Entry 的 after 作為下一個應該返回的節點即可。
直到到達雙向鏈表的尾部時，after 為雙向鏈表的表頭節點 Entry header，這時候 hasNext 就會返回 false，表示沒有下一個元素了。LinkedHashMap 的遍歷取值如下圖所示：
遍歷出來的結果為 Entry1、Entry2...Entry6。
可得，LinkedHashMap 是有序的，且是通過雙向鏈表來保證順序的。
1.9 remove方法
LinkedHashMap 沒有提供 remove 方法，所以調用的是 HashMap 的 remove 方法，實現如下：
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
final Entry<K,V> removeEntryForKey(Object key) {
int hash = (key == null) ? 0 : hash(key);
int i = indexFor(hash, table.length);
Entry<K,V> prev = table[I];
Entry<K,V> e = prev;
while (e != null) {
Entry<K,V> next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
// LinkedHashMap.Entry重寫了該方法
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
在 HashMap 中就分析了 remove 過程，其實就是斷開其他對象對自己的引用。
比如被刪除 Entry 是在單向鏈表的表頭，則讓它的 next 放到表頭，這樣它就沒有被引用了；如果不是在表頭，它是被別的 Entry 的 next 引用著，這時候就讓上一個 Entry 的 next 指向它自己的 next，這樣，它也就沒被引用了。
在 HashMap.Entry 中 recordRemoval 方法是空實現，但是 LinkedHashMap.Entry 對其進行了重寫，如下：
void recordRemoval(HashMap<K,V> m) {
remove();
}
private void remove() {
before.after = after;
after.before = before;
}
易知，這是要把雙向鏈表中的 Entry 刪除，也就是要斷開當前要被刪除的 Entry 被其他對象通過 after 和 before 的方式引用。
所以，LinkedHashMap 的 remove 操作。首先把它從 table 中刪除，即斷開 table 或者其他對象通過 next 對其引用，然后也要把它從雙向鏈表中刪除，斷開其他對應通過 after 和 before 對其引用。
2. HashMap 與 LinkedHashMap 的結構對比
3. LinkedHashMap 在 Android 中的應用
在 Android 中使用圖片時，一般會用 LruCacha 做圖片的內存緩存，它里面就是使用 LinkedHashMap 來實現存儲的。
public class LruCache<K, V> {
private final LinkedHashMap<K, V> map;
public LruCache(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
this.maxSize = maxSize;
// 注意第三個參數，是accessOrder，這里為true，后面會講到
this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
}
前面提到了，accessOrder 為 true，表示 LinkedHashMap 為訪問順序，當對已存在 LinkedHashMap 中的 Entry 進行 get 和 put 操作時，會把 Entry 移動到雙向鏈表的表尾（其實是先刪除，再插入）。
我們拿 LruCache 的 put 方法舉例：
public final V put(K key, V value) {
if (key == null || value == null) {
throw new NullPointerException("key == null || value == null");
}
V previous;
// 對map進行操作之前，先進行同步操作
synchronized (this) {
putCount++;
size += safeSizeOf(key, value);
previous = map.put(key, value);
if (previous != null) {
size -= safeSizeOf(key, previous);
}
}
if (previous != null) {
entryRemoved(false, key, previous, value);
}
// 整理內存，看是否需要移除LinkedHashMap中的元素
trimToSize(maxSize);
return previous;
}
之前提到了，HashMap 是線程不安全的，LinkedHashMap 同樣是線程不安全的。所以在對調用 LinkedHashMap 的 put 方法時，先使用 synchronized 進行了同步操作。
我們最關心的是倒數第一行代碼，其中 maxSize 為我們給 LruCache 設置的最大緩存大小。我們看看該方法：
/**
* Remove the eldest entries until the total of remaining entries is at or
* below the requested size.
*
* @param maxSize the maximum size of the cache before returning. May be -1
* to evict even 0-sized elements.
*/
public void trimToSize(int maxSize) {
// while死循環，直到滿足當前緩存大小小于或等于最大可緩存大小
while (true) {
K key;
V value;
// 線程不安全，需要同步
synchronized (this) {
if (size < 0 || (map.isEmpty() && size != 0)) {
throw new IllegalStateException(getClass().getName()
+ ".sizeOf() is reporting inconsistent results!");
}
// 如果當前緩存的大小，已經小于等于最大可緩存大小，則直接返回
// 不需要再移除LinkedHashMap中的數據
if (size <= maxSize || map.isEmpty()) {
break;
}
// 得到的就是雙向鏈表表頭header的下一個Entry
Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
key = toEvict.getKey();
value = toEvict.getValue();
// 移除當前取出的Entry
map.remove(key);
// 從新計算當前的緩存大小
size -= safeSizeOf(key, value);
evictionCount++;
}
entryRemoved(true, key, value, null);
}
}
從注釋上就可以看出，該方法就是不斷移除 LinkedHashMap 中雙向鏈表表頭的元素，直到當前緩存大小小于或等于最大可緩存的大小。
由前面的重排序我們知道，對 LinkedHashMap 的 put 和 get 操作，都會讓被操作的 Entry 移動到雙向鏈表的表尾，而移除是從 map.entrySet().iterator().next() 開始的，也就是雙向鏈表的表頭的 header 的 after 開始的，這也就符合了 LRU 算法的需求。
下圖表示了 LinkedHashMap 中刪除、添加、get/put 已存在的 Entry操作。
- 紅色表示初始狀態
- 紫色表示緩存圖片大小超過了最大可緩存大小時，才能夠表頭移除 Entry1
- 藍色表示對已存在的 Entry3 進行了 get/put 操作，把它移動到雙向鏈表表尾
- 綠色表示新增一個 Entry7，插入到雙向鏈表的表尾（暫時不考慮在 HashMap 中的位置）
4 總結
- LinkedHashMap 是繼承于 HashMap，是基于 HashMap 和雙向鏈表來實現的。
- HashMap 無序；LinkedHashMap 有序，可分為插入順序和訪問順序兩種。如果是訪問順序，那 put 和 get 操作已存在的 Entry 時，都會把 Entry 移動到雙向鏈表的表尾(其實是先刪除再插入)。
- LinkedHashMap 存取數據，還是跟 HashMap 一樣使用的 Entry[] 的方式，雙向鏈表只是為了保證順序。
- LinkedHashMap 是線程不安全的。
(參考鏈接](http://www.lxweimin.com/p/8f4f58b4b8ab)
PS:開始和結束的圖片來源網絡，侵刪
