其中，removeEldestEntry判断是否需要删除近不常使用的那个节点。LinkedHashMap中的removeEldestEntry(eldest)方法永远返回false，如果我们要实现LRU算法，需要重写这个方法，判断在什么情况下，删除近不常使用的节点。removeEntryForKey的作用是将key对应的节点在HashMap的数组加链表结构中删除，源码如下：
final Entry<K，V> removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
int i = indexFor(hash， table.length);
Entry<K，V> prev = table[i];
Entry<K，V> e = prev;
while (e != null) {
Entry<K，V> next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
　　removeEntryForKey是HashMap的方法，对LinkedHashMap中header的双向链表无能为力，而LinkedHashMap又没有重写这个方法，那header的双向链表要如何处理呢。
　　仔细看一下代码，可以看到在成功删除了HashMap中的节点后，调用了e.recordRemoval(this);方法。这个方法在HashMap中为空，LinkedHashMap的Entry则实现了这个方法。其中remove()方法中的两行代码为双向链表中删除当前节点的标准代码，不解释。
　　/**
　　* Removes this entry from the linked list.
　　*/
　　private void remove() {
　　before.after = after;
　　after.before = before;
　　}void recordRemoval(HashMap<K，V> m) {
　　remove();
　　}
　　以上，LinkedHashMap增加节点的代码分析完毕，可以看到完美的将新增的节点放在了header双向链表的末尾。
　　但是，这样显然是先进先出的算法，而不是近不常使用算法。需要在get的时候，更新header双向链表，把刚刚get的节点放到header双向链表的末尾。我们来看看get的源码：
　　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;
　　}
　　代码很短，第一行的getEntry调用的是HashMap的getEntry方法，不需要解释。真正处理header双向链表的代码是e.recordAccess(this)。看一下代码：
/**
* Removes this entry from the linked list.
*/
private void remove() {
before.after = after;
after.before = before;
}
/**
* Inserts this entry before the specified existing entry in the list.
*/
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);
}
}
　　首先在header双向链表中删除当前节点，再将当前节点添加到header双向链表的末尾。当然，在调用LinkedHashMap的时候，需要将accessOrder设置为true，否则是FIFO算法。
　　三、Android的LRU算法
　　Android同样提供了HashMap和LinkedHashMap，而且总体思路有些类似，但是实现的细节明显不同。而且Android提供的LruCache虽然使用了LinkedHashMap，但是实现的思路并不一样。Java需要重写removeEldestEntry来判断是否删除节点；而Android需要重写LruCache的sizeOf，返回当前节点的大小，Android会根据这个大小判断是否超出了限制，进行调用trimToSize方法清除多余的节点。
　　Android的sizeOf方法默认返回1，默认的方式是判断HashMap中的数据个数是否超出了设置的阈值。也可以重写sizeOf方法，返回当前节点的大小。Android的safeSizeOf会调用sizeOf方法，其他判断阈值的方法会调用safeSizeOf方法，进行加减操作并判断阈值。进而判断是否需要清除节点。
　　Java的removeEldestEntry方法，也可以达到同样的效果。Java需要使用者自己提供整个判断的过程，两者思路还是有些区别的。
　　sizeOf，safeSizeOf不需要说明，而put和get方法，虽然和Java的实现方式不完全一样，但是思路是相同的，也不需要分析。在LruCache中put方法的后，会调用trimToSize方法，这个方法用于清除超出的节点。它的代码如下：
public void trimToSize(int maxSize)
{
while (true)
{
Object key;
Object value;
synchronized (this) {
if ((this.size < 0) || ((this.map.isEmpty()) && (this.size != 0))) {
throw new IllegalStateException(getClass().getName() + ".sizeOf() is reporting inconsistent results!");
}
if (size <= maxSize) {
break;
}
Map.Entry toEvict = (Map.Entry)this.map.entrySet().iterator().next();
key = toEvict.getKey();
value = toEvict.getValue();
this.map.remove(key);
this.size -= safeSizeOf(key， value);
this.evictionCount += 1;
}
entryRemoved(true， key， value， null);
}
}
　　重点需要说明的是Map.Entry toEvict = (Map.Entry)this.map.entrySet().iterator().next();这行代码。它前面的代码判断是否需要删除近不常使用的节点，后面的代码用于删除具体的节点。这行代码用于获取近不常使用的节点。
　　首先需要说明的问题是，Android的LinkedHashMap和Java的LinkedHashMap在思路上一样，也是使用header保存双向链表。在put和get的时候，会更新对应的节点，保存header.after指向久没有使用的节点；header.before用于指向刚刚使用过的节点。所以Map.Entry toEvict = (Map.Entry)this.map.entrySet().iterator().next();这行终肯定是获取header.after节点。下面逐步分析代码，可以看到是如何实现的了。
　　首先，map.entrySet()，HashMap定义了这个方法，LinkedHashMap没有重写这个方法。因此调用的是HashMap对应的方法：
　　public Set<Entry<K， V>> entrySet() {
　　Set<Entry<K， V>> es = entrySet;
　　return (es != null) ? es : (entrySet = new EntrySet());
　　}
　　上面代码不需要细说，new一个EntrySet类的实例。而EntrySet也是在HashMap中定义，LinkedHashMap中没有。
private final class EntrySet extends AbstractSet<Entry<K， V>> {
public Iterator<Entry<K， V>> iterator() {
return newEntryIterator();
}
public boolean contains(Object o) {
if (!(o instanceof Entry))
return false;
Entry<?， ?> e = (Entry<?， ?>) o;
return containsMapping(e.getKey()， e.getValue());
}
public boolean remove(Object o) {
if (!(o instanceof Entry))
return false;
Entry<?， ?> e = (Entry<?， ?>)o;
return removeMapping(e.getKey()， e.getValue());
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public void clear() {
HashMap.this.clear();
}
}
Iterator<Entry<K， V>> newEntryIterator() { return new EntryIterator(); }
　　代码中很明显的可以看出，Map.Entry toEvict = (Map.Entry)this.map.entrySet().iterator().next()，是要调用newEntryIterator().next()，是调用(new
EntryIterator()).next()。而EntryIterator类在LinkedHashMap中是有定义的。
private final class EntryIterator
extends LinkedHashIterator<Map.Entry<K， V>> {
public final Map.Entry<K， V> next() { return nextEntry(); }
}
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;
}
}
　　现在可以得到结论，trimToSize中的那行代码得到的是header.next对应的节点，也是近不常使用的那个节点。