public class LinkedHashMap<K,V>
    extends HashMap<K,V> //繼承了HashMap
    implements Map<K,V>//實現(xiàn)了Map接口
{

     private transient Entry<K,V> header; //頭結(jié)點
     private final boolean accessOrder;//順序性； true(訪問有序); false(插入有序)

//子類重寫方法；
@Override
    void init() {
        header = new Entry<>(-1, null, null, null); //hash值為-1；
        header.before = header.after = header;
    }
   //父類構(gòu)造函數(shù)：
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        threshold = initialCapacity;
        init(); //在LinkedHashMap起作用，用來初始化header;
    }

 public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);//調(diào)用父類的構(gòu)造函數(shù)
        accessOrder = false; 
    }
     //只指定數(shù)組大小
    public LinkedHashMap(int initialCapacity) {
        super(initialCapacity); 
        accessOrder = false;
    }
    public LinkedHashMap() {
        super();
        accessOrder = false;
    }
    public LinkedHashMap(Map<? extends K, ? extends V> m) {
        super(m);
        accessOrder = false;
    }
     //指定數(shù)組大小。加載因子，以及確定使用何種有序
    public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }

// （父類HashMap實現(xiàn)）
public V put(K key, V value) {
    if (table == EMPTY_TABLE) {//如果table為空，創(chuàng)建默認數(shù)組
        inflateTable(threshold);
    }
    if (key == null)//對key進行特殊處理，key為null總在0號角標鏈表中
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length); //通過hash找到對應(yīng)角標
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
    //遍歷該角標倆表，找到對應(yīng)key值
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
        //找到key值將value值進行更新，并返回舊的value值
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);//此方法在子類LinkedHashMap重寫，發(fā)揮作用；
				//針對LinkedHashMap,確定是插入有序，還是插入有序；
				//如果是訪問有序，將原節(jié)點刪除，并添加到header最后
            return oldValue;
        }
    }
    modCount++;
    addEntry(hash, key, value, i);//現(xiàn)有集合中沒找到key，那么創(chuàng)建一個新的entry實體
    return null;
}
//（當前類LinkedHashMap實現(xiàn)）
void addEntry(int hash, K key, V value, int bucketIndex) {
//目前此函數(shù)并沒有看出與父類的區(qū)別
    super.addEntry(hash, key, value, bucketIndex);//調(diào)用父類創(chuàng)建entry實體
    // Remove eldest entry if instructed
    Entry<K,V> eldest = header.after;
    if (removeEldestEntry(eldest)) {//總返回false；這句等于無效代碼，留作后用；
        removeEntryForKey(eldest.key);
    }
}
//（父類HashMap實現(xiàn)）
void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
    //如果集合中元素個數(shù)已經(jīng)大于閾值，那么進行擴容；
        resize(2 * table.length);//二倍擴容
        hash = (null != key) ? hash(key) : 0; 
        bucketIndex = indexFor(hash, table.length); 找到新的key對應(yīng)的數(shù)組角標
    }
    createEntry(hash, key, value, bucketIndex);//創(chuàng)建entry實體，子類重寫
}
//（當前類LinkedHashMap實現(xiàn)）
void createEntry(int hash, K key, V value, int bucketIndex) {
    HashMap.Entry<K,V> old = table[bucketIndex];
    Entry<K,V> e = new Entry<>(hash, key, value, old);//頭插法
    table[bucketIndex] = e;
    e.addBefore(header);//實現(xiàn)第二功能，使數(shù)據(jù)實現(xiàn)插入有序；
    size++;
}
//（當前類LinkedHashMap實現(xiàn)） ,addBefore為子類Entry內(nèi)部類中的方法，
//Entry多了兩個屬性，before(前驅(qū))，after(后驅(qū))
private void addBefore(Entry<K,V> existingEntry) {
//使header實現(xiàn)插入有序，header所處鏈表實質(zhì)上為一個循環(huán)的雙向鏈表；
//將header.after理解為頭結(jié)點的下一個結(jié)點，將header.before理解為尾結(jié)點；新結(jié)點插入位置為尾插
    after  = existingEntry;//新的尾結(jié)點鏈接頭結(jié)點
    before = existingEntry.before;//新的尾結(jié)點的前驅(qū)鏈接舊的尾結(jié)點
    before.after = this;//舊的尾結(jié)點的下一結(jié)點鏈接新的尾結(jié)點
    after.before = this;//新的尾結(jié)點的下一結(jié)點的前驅(qū)鏈接新的尾結(jié)點
    //當然這句代碼可以改為existingEntry.before=this;//頭結(jié)點的前驅(qū)鏈接新的尾結(jié)點
}
  //根據(jù)put操作和get操作，并且根據(jù)當前集合是插入有序還是訪問有序，進行操作； 
  void recordAccess(HashMap<K,V> m) { 
            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
            if (lm.accessOrder) { //訪問有序，刪除原節(jié)點，并將新節(jié)點添加到最后；
                lm.modCount++;
                remove();//刪除當前節(jié)點
                addBefore(lm.header);//在末尾添加被刪除節(jié)點
            }
        }