LinkedHashMap是HashMap的字类，但它是有序的，那它是怎么实现的呢，看源码

@Override 
void addNewEntry(K key, V value, int hash, int index) {
     LinkedEntry<K, V> header = this.header;

     // Remove eldest entry if instructed to do so.
     LinkedEntry<K, V> eldest = header.nxt;
     if (eldest != header && removeEldestEntry(eldest)) {
         remove(eldest.key);
     }

     // Create new entry, link it on to list, and put it into table
     LinkedEntry<K, V> oldTail = header.prv;
     LinkedEntry<K, V> newTail = new LinkedEntry<K,V>(
             key, value, hash, table[index], header, oldTail);
     table[index] = oldTail.nxt = header.prv = newTail;
}

主要就是这个this.header的值，在每次put数据时都会更新结构，最终形成如下图所示的结构

linkedHashMap.jpg

当遍历数据时，先看下源码

private abstract class LinkedHashIterator<T> implements Iterator<T> {
    LinkedEntry<K, V> next = header.nxt;
    LinkedEntry<K, V> lastReturned = null;
    int expectedModCount = modCount;

    public final boolean hasNext() {
        return next != header;
    }

    final LinkedEntry<K, V> nextEntry() {
        if (modCount != expectedModCount)
             throw new ConcurrentModificationException();
         LinkedEntry<K, V> e = next;
         if (e == header)
             throw new NoSuchElementException();
         next = e.nxt;
         return lastReturned = e;
     }

     public final void remove() {
         if (modCount != expectedModCount)
             throw new ConcurrentModificationException();
         if (lastReturned == null)
             throw new IllegalStateException();
         LinkedHashMap.this.remove(lastReturned.key);
         lastReturned = null;
         expectedModCount = modCount;
     }
}

就是循环获取this.header的nxt参数值，直至获取的到next值与header值相等，则结束，就如上图中的红色箭头方向一样。