LinkedHashMap源码剖析

先贴上源代码

使用的JDK版本：1.7.0_13

/*
 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

import java.io.*;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;


public class LinkedHashMap<K,V> extends HashMap<K,V>  implements Map<K,V>
{

    private static final long serialVersionUID = 3801124242820219131L;

    /**
     *  禁止序列化，链表头
     */
    private transient Entry<K,V> header;

    /**
     * The iteration ordering method for this linked hash map: <tt>true</tt>
     * for access-order, <tt>false</tt> for insertion-order.
     * 
     * accessOrder为true时，记录访问顺序，将最新访问的元素添加到双向链表的表头，
     *  并从原来的位置删除。由于的链表的增加、删除操作是常量级的，故并不会带来性能的损失。
     *  该操作可以对于频繁遍历固定元素时，提高效率
     */
    private final boolean accessOrder;

    //构造方法都是调用HashMap的构造方法，默认不进行自动记录访问历史
    public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
    }

    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;
    }

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

    @Override
    void init() {
        header = new Entry<>(-1, null, null, null);
        header.before = header.after = header;
    }

    @Override
    void transfer(HashMap.Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        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;
        }
    }

    public boolean containsValue(Object value) {
        // Overridden to take advantage of faster iterator
        if (value==null) {
            for (Entry e = header.after; e != header; e = e.after)
                if (e.value==null)
                    return true;
        } else {
            for (Entry e = header.after; e != header; e = e.after)
                if (value.equals(e.value))
                    return true;
        }
        return false;
    }

    public V get(Object key) {
        Entry<K,V> e = (Entry<K,V>)getEntry(key);
        if (e == null)
            return null;
        e.recordAccess(this);
        return e.value;
    }

    /**
     * Removes all of the mappings from this map.
     * The map will be empty after this call returns.
     */
    public void clear() {
        super.clear();
        header.before = header.after = header;
    }

    /**
     * LinkedHashMap entry继承自HashMap的静态内部类Entry，并创建了before和after元素，构成双向链表.
     */
    private static class Entry<K,V> extends HashMap.Entry<K,V> {
        // These fields comprise the doubly linked list used for iteration.
        Entry<K,V> before, after;

        Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
            super(hash, key, value, next);
        }

        /**
         * 链表删除，只是指针从新移位
         */
        private void remove() {
            before.after = after;
            after.before = before;
        }

        //此处，插入元素之后，当前元素位于链表的最后，
        // header的after是第一个插入的元素，header的before为当前元素
        // 当前元素的after为Header元素，当前元素的before为前面链表的最后一个元素
        private void addBefore(Entry<K,V> existingEntry) {
            after  = existingEntry;
            before = existingEntry.before;
            before.after = this;
            after.before = this;
        }

        //如果启动了访问排序，则每次访问后，就相当去新加了当前访问的元素，这样header.after将渐渐指向最老访问的对象
        //这样结合removeEldestEntry方法就可以保持LinkedHashMap的大小固定并且使用保留访问频率最高的元素
        void recordAccess(HashMap<K,V> m) {
            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
            if (lm.accessOrder) {
                lm.modCount++;
                remove();
                addBefore(lm.header);
            }
        }

        void recordRemoval(HashMap<K,V> m) {
            remove();
        }
    }

    //此处为抽象内部类，新加了nextEntry方法，next方法在KeyIterator类中实现
    private abstract class LinkedHashIterator<T> implements Iterator<T> {
        Entry<K,V> nextEntry    = header.after;
        Entry<K,V> lastReturned = null;

        int expectedModCount = modCount;

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

        public void remove() {
            if (lastReturned == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();

            LinkedHashMap.this.remove(lastReturned.key);
            lastReturned = null;
            expectedModCount = modCount;
        }

        //此处是关键，使nextEntry指向了当前元素的after元素
        Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (nextEntry == header)
                throw new NoSuchElementException();
            //此处初始化时，已经指定Entry<K,V> nextEntry    = header.after;
            // 因此，直接返回当前的e（第一次访问为：header.after）,并使nextEntry指向e.after
            // 以此来实现链式访问
            Entry<K,V> e = lastReturned = nextEntry;
            nextEntry = e.after;
            return e;
        }
    }

    private class KeyIterator extends LinkedHashIterator<K> {
        public K next() { return nextEntry().getKey(); }
    }

    private class ValueIterator extends LinkedHashIterator<V> {
        public V next() { return nextEntry().value; }
    }

    private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
        public Map.Entry<K,V> next() { return nextEntry(); }
    }

    // These Overrides alter the behavior of superclass view iterator() methods
    Iterator<K> newKeyIterator()   { return new KeyIterator();   }
    Iterator<V> newValueIterator() { return new ValueIterator(); }
    Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); }

    void addEntry(int hash, K key, V value, int bucketIndex) {
        //此处调用父类HashMap的addEntry，由于父类该方法调用了 createEntry(hash, key, value, bucketIndex);，
        //又重新调回自己的createEntry(int hash, K key, V value, int bucketIndex)，其实只是使用了HashMap的扩容
        super.addEntry(hash, key, value, bucketIndex);

        // 如果需要的话，可以删除旧的元素
        Entry<K,V> eldest = header.after;
        if (removeEldestEntry(eldest)) {
            removeEntryForKey(eldest.key);
        }
    }

    //此方法最为重要，此处先找到就得链表，创建当前元素，并将当前元素的next指向就列表，把当前元素插入table中，
    //并插入到整个双向链表头
    //这样，就构成了一个带有双向链表的数组加链表结果，get时可以充分发挥HashMap的优势，遍历时，又可以依据双向链表进行遍历
    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);
        size++;
    }

    //结合此方法可以实现LinkedHashMap大小固定，同时在开启访问排序模式，可以一直保存最近访问的记录
    //例如：return size>100，并且使用 public LinkedHashMap(int initialCapacity,float loadFactor, boolean accessOrder)
    //accessOrder=true来构造LinkedHashMap，即可实现该功能
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }
}

通过上面可知，LinkedHashMap继承了HashMap，多维护了一个双向链表，并且支持插入排序和访问排序两种排序方式（实际使用中，大多数人只知道插入排序，访问排序使用的很少），他的Get操作和Put操作时间上和HashMap一样，操作效率等同于HashMap。

• 插入模式中，header元素的after指针指向最先放入的元素,before指针指向最近放入的元素，使用Iterator便可以从header开始，依次访问after遍历完所有元素，如果当前元素的after指向header，则访问结束。
• 访问模式中，每次最近的访问都会改变双向链表，结果使每次访问都重新put了一次，因此能将最久没访问的变量压到header的after指针位置，就相当于第一次放入的位置。依靠此逻辑，结合removeEldestEntry方法实现LRU缓存功能。