LinkedHashMap源码分析

接上一节关于HashMap的分析：

LinkedHashMap继承HashMap,所以HashMap是LinkedHashMap的父类，HashMap有的方法LinkedHashMap都有，LinkedHashMap也会重写某些方法，我们知道，HashMap底层数据结构是数组和链表，那么LinkedHashMap会额外维护一个按照插入顺序排序的双向循环列表。

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

这是linkedhashmap其中的一个构造方法，这里注意accessOrder这个参数，默认为false，那就按照插入的顺序排序，依靠那个双向循环列表来实现，如果传入accessOrder为true时，那将按照LRU算法来实现。

 void recordAccess(HashMap<K,V> m) {            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;            if (lm.accessOrder) {                lm.modCount++;                remove();                addBefore(lm.header);            }        }

先来看这个重要的方法，这个方法是在哪里调用的呢，

public V get(Object key) {        Entry<K,V> e = (Entry<K,V>)getEntry(key);        if (e == null)            return null;       <span style="color:#ff0000;"> e.recordAccess(this);</span>        return e.value;    }

public V put(K key, V value) {        if (key == null)            return putForNullKey(value);        int hash = hash(key.hashCode());        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;                <span style="color:#ff0000;">e.recordAccess(this);</span>                return oldValue;            }        }        modCount++;        addEntry(hash, key, value, i);        return null;    }

put方法没有重写，所以put方法还是用的父类HashMap的put（）方法，说明在put和get时会调用recordAccess方法，就是在访问元素时调用，我们接着看这个put方法，在里面调用了addEntry方法，所以linkedhashmap 重写了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);        }    }

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

可以发现，addEntry调用了createEntry方法，这个就是加入元素的过程，显然，这里加入了两次，在hash数组中加入，还要addBefore，即在双向循环列表中加入，加在头结点之后，即元素末尾。接下来再来看这个方法：

 void recordAccess(HashMap<K,V> m) {            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;            if (lm.accessOrder) {                lm.modCount++;                remove();                addBefore(lm.header);            }        }

如果accessOrder为true，调用remove移除这个entry,并且把这个加到双向链表的末尾，这样就实现了LRU。

再来看这几行代码：

 Entry<K,V> eldest = header.after;        if (<span style="color:#ff0000;">removeEldestEntry(eldest)</span>) {            removeEntryForKey(eldest.key);        } else {            if (size >= threshold)                resize(2 * table.length);        }

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

默认是返回false，如果我们自己实现的话，可以通过重写这个方法来设置删除头结点之后的元素，即最老元素。

看来，通过源码还是可以学习好多东西的。