LinkedHashMap类源码解析

LinkedHashMap
1.通过链表实现存储，可以根据插入顺序遍历数组
2.hashcode计算方法和HashMap的一样

继承HashMap
实现Map

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;

    /**
     * 遍历的顺序 对于访问顺序，为true；对于插入顺序，则为false(默认）
     * true for access-order, <tt>false</tt> for insertion-order.
     *
     * @serial
     */
    private final boolean accessOrder;

构造函数

    /**
     * 构造函数
     *
     * @param  initialCapacity 初始容量
     * @param  loadFactor      装载因子
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive
     */
    public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
    }

    /**
     * 装载因子0.75的构造函数
     * @param  initialCapacity 初始容量
     * @throws IllegalArgumentException if the initial capacity is negative
     */
    public LinkedHashMap(int initialCapacity) {
        super(initialCapacity);
        accessOrder = false;
    }

    /**
     * 构造函数  
     *default initial capacity (16) and load factor (0.75).
     */
    public LinkedHashMap() {
        super();
        accessOrder = false;
    }

    /**
     * 构造函数：m集合元素加入到当前map中
     *  default load factor (0.75) 
     * @param  m the map whose mappings are to be placed in this map
     * @throws NullPointerException if the specified map is null
     */
    public LinkedHashMap(Map<? extends K, ? extends V> m) {
        super(m);
        accessOrder = false;
    }

    /**
     * 构造函数 
     * @param  initialCapacity the initial capacity
     * @param  loadFactor      the load factor
     * @param  accessOrder     the ordering mode - <tt>true</tt> for
     *         access-order, <tt>false</tt> for insertion-order
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive
     */
    public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }

结点定义结构

    /**
     * LinkedHashMap entry.结点定义
     */
    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);
        }

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

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

        /**
         * This method is invoked by the superclass whenever the value
         * of a pre-existing entry is read by Map.get or modified by Map.set.
         * If the enclosing Map is access-ordered, it moves the entry
         * to the end of the list; otherwise, it does nothing.
         */
        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();
        }
    }

双链表的初始化

    /**
     * 初始化，可以看出有一个头指针
     */
    @Override
    void init() {
        header = new Entry<>(-1, null, null, null);
        header.before = header.after = header;
    }

    /**
     * Transfers all entries to new table array.  This method is called
     * by superclass resize.  It is overridden for performance, as it is
     * faster to iterate using our linked list.
     */
    @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;
        }
    }

containsValue
直接根据双链表进行顺序遍历、
重写了HashMap的containsValue，效率提高

    /**
     * containsValue
     * @param value value whose presence in this map is to be tested
     * @return <tt>true</tt> if this map maps one or more keys to the
     *         specified value
     */
    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;
    }

没有实现containsKey方法
HashMap中是根据key计算hashcode，找到对应的table[i]，在顺序查找，现在这个查找效率比较高，毕竟只遍历了部分数据。

clear

    /**
     * clear
     */
    public void clear() {
        super.clear();
        header.before = header.after = header;
    }

get
getEntry 方法是调用父类，其程序原理和containsKey方法一样，在HashMap中containsKey方法调用的getEntry方法。

    /**
     * V get(Object key)
     */
    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;
    }

LinkedHashMap没有实现put方法，其重写了HashMap.put里面的recordAccess、addEntry方法
HashMap.put

    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key); // 计算hash值 
        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; // key已经存在，新的value 更新老的value 
                e.recordAccess(this); 
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i); // 不存在时候  插入该新的节点 
        return null;
    }

LinkedHashMap重写recordAccess、addEntry方法

    /**
     * 重写HashMap的方法，
     * This override alters behavior of superclass put method. It causes newly
     * allocated entry to get inserted at the end of the linked list and
     * removes the eldest entry if appropriate.
     */
    void addEntry(int hash, K key, V value, int bucketIndex) {
        super.addEntry(hash, key, value, bucketIndex); // 父类方法 

        // Remove eldest entry if instructed
        Entry<K,V> eldest = header.after;
        if (removeEldestEntry(eldest)) {
            removeEntryForKey(eldest.key);
        }
    }

    /**
     * This override differs from addEntry in that it doesn‘t resize the
     * table or remove the eldest entry.
     */
    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); // 新结点 e 
        table[bucketIndex] = e; // table 中加入结点 e 
        e.addBefore(header); // 加入到头部 
        size++;
    }

    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }
}

可以看出，表面上LinkedHashMap通过双链表作为存储结构，其实双链表只是记录结点的插入顺序，方便了对LinkedHashMap中结点的遍历，其父类的table同样作为存储结构，table的存在是使得相同的hashcode的结点将会存储在同一个table[i]桶内。符合Map的定义，如果没有table数组，直接双链表存储，没有必要计算hashcode，与LinkedList几乎意义一样。 table数组的存在，在get方法和containsKey方法中用到，LinkedHashMap没有重写containsKey方法，上面有讲解。

迭代器

    // 根据插入顺序的迭代器 
    private abstract class LinkedHashIterator<T> implements Iterator<T> {
        Entry<K,V> nextEntry    = header.after;
        Entry<K,V> lastReturned = null;

        /**
         * The modCount value that the iterator believes that the backing
         * List should have.  If this expectation is violated, the iterator
         * has detected concurrent modification.
         */
        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;
        }

        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;
        }
    }
    // KeyIterator 
    private class KeyIterator extends LinkedHashIterator<K> {
        public K next() { return nextEntry().getKey(); }
    }
    // ValueIterator
    private class ValueIterator extends LinkedHashIterator<V> {
        public V next() { return nextEntry().value; }
    }
    // EntryIterator
    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(); }