LinkedHashMap是什麼

1. LinkedHashMap是基於雜湊表的Map介面的非同步實現
2. LinkedHashMap是HashMap的子類
3. LinkedHashMap是有序的
4. LinkedHashMap中元素的key是唯一的、value值可重複
5. LinkedHashMap允許null鍵和null值

LinkedHashMap的有序性

LinkedHashMap底層使用雜湊表與雙向連結串列來儲存所有元素，它維護著一個運行於所有條目的雙向連結串列（如果學過雙向連結串列的同學會更好的理解它的原始碼），此連結串列定義了迭代順序，該迭代順序可以是插入順序或者是訪問順序

1. 按插入順序的連結串列：在LinkedHashMap呼叫get方法後，輸出的順序和輸入時的相同，這就是按插入順序的連結串列，預設是按插入順序排序
2. 按訪問順序的連結串列：在LinkedHashMap呼叫get方法後，會將這次訪問的元素移至連結串列尾部，不斷訪問可以形成按訪問順序排序的連結串列。簡單的說，按最近最少訪問的元素進行排序（類似LRU演算法）

我們可以通過例子來理解我們上面所說的LinkedHashMap的插入順序和訪問順序

public static void main(String[] args) {
    Map<String, String> map = new HashMap<String, String>();
    map.put("apple", "蘋果");
    map.put("watermelon"
 
, "西瓜");
    map.put("banana", "香蕉");
    map.put("peach", "桃子");

    Iterator iter = map.entrySet().iterator();
    while (iter.hasNext()) {
        Map.Entry entry = (Map.Entry) iter.next();
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }
}

上面是簡單的HashMap程式碼，通過控制檯的輸出，我們可以看到HashMap是沒有順序的

banana=香蕉
apple=蘋果
peach=桃子
watermelon=西瓜

我們現在將HashMap換成LinkedHashMap，其他程式碼不變

Map<String, String> map = new LinkedHashMap<String, String>();

看一下控制檯的輸出

apple=蘋果
watermelon=西瓜
banana=香蕉
peach=桃子

我們可以看到，其輸出順序是完成按照插入順序的，也就是我們上面所說的保留了插入的順序。下面我們修改一下程式碼，通過訪問順序進行排序

public static void main(String[] args) {
    Map<String, String> map = new LinkedHashMap<String, String>(16,0.75f,true);
    map.put("apple", "蘋果");
    map.put("watermelon", "西瓜");
    map.put("banana", "香蕉");
    map.put("peach", "桃子");

    map.get("banana");
    map.get("apple");

    Iterator iter = map.entrySet().iterator();
    while (iter.hasNext()) {
        Map.Entry entry = (Map.Entry) iter.next();
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }
}

程式碼與之前的相比

1. 替換了LinkedHashMap的建構函式，使用三個引數的建構函式，第三個引數傳進true就是表明用訪問順序來排序，預設是false（即插入順序）
2. 增加了兩句LinkedHashMap的get方法，來表示最近已經訪問過這兩個元素了

//修改的程式碼
Map<String, String> map = new LinkedHashMap<String, String>(16,0.75f,true);
......
map.get("banana");
map.get("apple");

看一下控制檯的輸出結果

watermelon=西瓜
peach=桃子
banana=香蕉
apple=蘋果

我們可以看到，順序是先從最少訪問的元素開始遍歷（西瓜、桃子），而香蕉、蘋果是因為分別呼叫了get方法，香蕉是最先訪問的，所以它的比蘋果更少用一些。這也就是我們之前提到過的，LinkedHashMap可以選擇按照訪問順序進行排序

LinkedHashMap的成員變數

LinkedHashMap採用的hash演算法和HashMap相同，但是它重新定義了陣列中儲存的元素Entry，該Entry除了儲存當前物件的引用外，還儲存了其上一個元素before和下一個元素after的引用，從而在雜湊表的基礎上又構成了雙向連結列表

/**
 * 如果為true，則按照訪問順序；如果為false，則按照插入順序。
 */
private final boolean accessOrder;
/**
 * 雙向連結串列的表頭元素。
 */
private transient Entry<K,V> header;

/**
 * LinkedHashMap的Entry元素。
 * 繼承HashMap的Entry元素，又儲存了其上一個元素before和下一個元素after的引用。
 */
private static class Entry<K,V> extends HashMap.Entry<K,V> {
    Entry<K,V> before, after;
    ……
}

LinkedHashMap的初始化

對於LinkedHashMap而言，它可以通過重寫父類相關的方法，來實現自己的連結列表特性。通過原始碼可以看出，在LinkedHashMap的構造方法中，實際呼叫了父類HashMap的相關構造方法來構造一個底層存放的table陣列，但額外可以增加accessOrder這個引數，如果不設定，預設為false，代表按照插入順序進行迭代，當然可以顯式設定為true，代表以訪問順序進行迭代

public LinkedHashMap(int initialCapacity, float loadFactor,boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

我們已經知道 LinkedHashMap的Entry元素繼承HashMap的Entry，提供了雙向連結串列的功能。在上述HashMap的構造器中，最後會呼叫init() 方法，進行相關的初始化，這個方法在HashMap的實現中並無意義，只是提供給子類實現相關的初始化呼叫，但在LinkedHashMap重寫了 init() 方法，在呼叫父類的構造方法完成構造後，進一步實現了對其元素Entry的初始化操作

@Override
void init() {
  header = new Entry<>(-1, null, null, null);
  //雙向連結串列的空實現
  header.before = header.after = header;
}

LinkedHashMap的儲存

LinkedHashMap並未重寫父類HashMap的 put 方法，而是重寫了父類HashMap的put方法呼叫的子方法void recordAccess(HashMap m) ，void addEntry(int hash, K key, V value, int bucketIndex) 和void createEntry(int hash, K key, V value, int bucketIndex)，提供了自己特有的雙向連結列表的實現

首先先看下HashMap的put方法

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        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++;
        addEntry(hash, key, value, i);
        return null;
}

重寫方法

void recordAccess(HashMap<K,V> m) {
    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
    if (lm.accessOrder) {
        lm.modCount++;
        remove();
        addBefore(lm.header);
        }
}

void addEntry(int hash, K key, V value, int bucketIndex) {
    // 呼叫create方法，將新元素以雙向連結串列的的形式加入到對映中。
    createEntry(hash, key, value, bucketIndex);

    // 刪除最近最少使用元素的策略定義
    Entry<K,V> eldest = header.after;
    if (removeEldestEntry(eldest)) {
        removeEntryForKey(eldest.key);
    } else {
        if (size >= threshold)
            resize(2 * table.length);
    }
}

void createEntry(int hash, K key, V value, int bucketIndex) {
    HashMap.Entry<K,V> old = table[bucketIndex];
    Entry<K,V> e = new Entry<K,V>(hash, key, value, old);
    table[bucketIndex] = e;
    // 呼叫元素的addBrefore方法，將元素加入到雜湊、雙向連結列表。  
    e.addBefore(header);
    size++;
}

private void addBefore(Entry<K,V> existingEntry) {
    after  = existingEntry;
    before = existingEntry.before;
    before.after = this;
    after.before = this;
}

LinkedHashMap的讀取

LinkedHashMap重寫了父類HashMap的get方法，實際在呼叫父類getEntry()方法取得查詢的元素後，再判斷當排序模式accessOrder為true時，記錄訪問順序，將最新訪問的元素新增到雙向連結串列的表頭，並從原來的位置刪除。由於的連結串列的增加、刪除操作是常量級的，故並不會帶來效能的損失

public V get(Object key) {
    // 呼叫父類HashMap的getEntry()方法，取得要查詢的元素。
    Entry<K,V> e = (Entry<K,V>)getEntry(key);
    if (e == null)
        return null;
    // 記錄訪問順序。
    e.recordAccess(this);
    return e.value;
}

void recordAccess(HashMap<K,V> m) {
    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
    // 如果定義了LinkedHashMap的迭代順序為訪問順序，
    // 則刪除以前位置上的元素，並將最新訪問的元素新增到連結串列表頭。  
    if (lm.accessOrder) {
        lm.modCount++;
        remove();
        addBefore(lm.header);
    }
}

private void remove() {
    before.after = after;
    after.before = before;
}

/**clear連結串列，設定header為初始狀態*/
public void clear() {
 super.clear();
 header.before = header.after = header;
}

LinkedHashMap其他API

1. removeEldestEntry(Map.Entry< K,V> eldest)：該方法可以提供在每次新增新條目時移除最舊條目的實現程式，預設返回 false，即永遠不能移除最舊的元素

LinkedHashMap與HashMap的區別