LinkedHashMap源码分析（一）

LinkedHashMap 表示链散列映射表：继承了散列映射表HashMap,实现了Map接口。LinkedHashMap用的是访问顺序而不是插入顺序，对映射表条目进行迭代。每次调用get或put方法时，受到影响的条目都会被删除并放到链表的尾部（只有条目在链表中的位置会受影响，而散列表中的桶不会受到影响，一个条目总位于键散列码对应的桶中）。访问顺序有利于实现高速缓存的“最近最少使用”。例如，可能希望将访问频率搞得元素放在内存中，访问频率低的从数据库中读取。当表中找不到所需的元素项而表又满了，就可以将迭代器加入到表中，并将枚举的前几个元素删除。这些事近期最少使用的元素。这一过程可以自动化，只需要覆盖下面的方法：

protected boolean removeEldestEntry(Map.Entry eldest)

源码里面给了一个例子，可以缓存100个元素：

 private static final int MAX_ENTRIES = 100;               protected boolean removeEldestEntry(Map.Entry eldest) {           return size() > MAX_ENTRIES;         }

每当方法放回true时，就添加一个新的条目，从而导致删除eldest条目。

这是为什么呢？看一下addEntry()方法就明白了：

    void addEntry(int hash, K key, V value, int bucketIndex) {        createEntry(hash, key, value, bucketIndex);        // Remove eldest entry if instructed, else grow capacity if appropriate        Entry<K,V> eldest = header.after;        if (removeEldestEntry(eldest)) {            removeEntryForKey(eldest.key);        } else {            if (size >= threshold)                resize(2 * table.length);        }    }

if(removeEldestEntry(eldest))巧妙的调用了removeEldestEntry方法。

在看一下LinkedHashMap的内部迭代器，感觉写的很好（对我来讲源码写的都很好）：

private abstract class HashIterator<E> implements Iterator<E> {        Entry<K,V> next;// next entry to return        int expectedModCount;// For fast-fail        int index;// current slot        Entry<K,V> current;// current entry        HashIterator() {            expectedModCount = modCount;            if (size > 0) { // advance to first entry                Entry[] t = table;                while (index < t.length && (next = t[index++]) == null)                    ;            }        }        public final boolean hasNext() {            return next != null;        }        final Entry<K,V> nextEntry() {            if (modCount != expectedModCount)                throw new ConcurrentModificationException();            Entry<K,V> e = next;            if (e == null)                throw new NoSuchElementException();            if ((next = e.next) == null) {                Entry[] t = table;                while (index < t.length && (next = t[index++]) == null)                    ;            }    current = e;            return e;        }        public void remove() {            if (current == null)                throw new IllegalStateException();            if (modCount != expectedModCount)                throw new ConcurrentModificationException();            Object k = current.key;            current = null;            HashMap.this.removeEntryForKey(k);            expectedModCount = modCount;        }    }

expectedModCount 是迭代器内部的修改计数器，初始化的时候等于集合的modCount,当一个集合有多个迭代器时，会出现一个问题：就是迭代器a在对集合进行修改前已经有其他迭代器对集合进行了结构化修改，所以会导致两个计数器数值不一致，此时就会抛出ConcurrentModificationException同时修改异常。