LinkedHashMap原理及LRU应用

1. LinkedHashMap概述
   本文基于JDK8，之前版本可能不一样。
   LinkedHashMap是HashMap的一个子类，它保留插入的顺序，如果需要输出的顺序和输入时的相同，那么就选用LinkedHashMap。
   LinkedHashMap实现与HashMap的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。
   根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序(调用get方法)的链表。
   默认是按插入顺序排序，如果指定按访问顺序排序，那么调用get方法后，会将这次访问的元素移至链表尾部，不断访问可以形成按访问顺序排序的链表。 可以重写removeEldestEntry方法返回true值指定插入元素时移除最老的元素。
   2.实现原理

 public LinkedHashMap(int initialCapacity) {
        super(initialCapacity);
        //默认false，表示根据插入顺序排序。true则根据访问顺序，最后访问在最后
        accessOrder = false;
    }

LinkedHashMap中没有实现put操作，直接调用的HashMap中的put，在HashMap中put又调用putVal方法。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
        //在LinkedHashMap中newNode是被重新了的
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))//数组中Entry第一个就是key
                e = p;
            else if (p instanceof TreeNode)
                //jdk8中map冲突产生链，超过TREEIFY_THRESHOLD（默认8）后采用红黑树存储Entry
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //e如果不为null则表示put为替换操作
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                //该函数表示节点被访问过后做的相应的处理，HashMap中为一个空函数，LinkedHashMap中有实现
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        //该函数表示插入节点后相应的处理，HashMap中为一个空函数，LinkedHashMap中有实现
        afterNodeInsertion(evict);
        return null;
    }

LinkedHashMap的重写方法如下：

Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
        LinkedHashMap.Entry<K,V> p =
            new LinkedHashMap.Entry<K,V>(hash, key, value, e);
        //将新加进来的放入LinkedHashMap的链的最后，进而实现顺序
        linkNodeLast(p);
        return p;
    }
     void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        //accessOrder即构造函数中的，if中操作即将e放入尾巴
        if (accessOrder && (last = tail) != e) {
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            if (b == null)
                head = a;
            else
                b.after = a;
            if (a != null)
                a.before = b;
            else
                last = b;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }
    //主要功能就是删除最老的
void afterNodeInsertion(boolean evict) { 
        LinkedHashMap.Entry<K,V> first;
        //LinkedHashMap中removeEldestEntry永远返回false，所以不会删除最老节点，但是可以通过重写removeEldestEntry实现删除，即LRU算法
        if (evict && (first = head) != null && removeEldestEntry(first)) {
            K key = first.key;
            removeNode(hash(key), key, null, false, true);
        }
    }
     protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }

LRU实现：

 //扩展一下LinkedHashMap这个类，让他实现LRU算法  
    class LRULinkedHashMap<K,V> extends LinkedHashMap<K,V>{  
        //定义缓存的容量  
        private int capacity;  
        private static final long serialVersionUID = 1L;  
        //带参数的构造器     
        LRULinkedHashMap(int capacity){  
            //调用LinkedHashMap的构造器，传入以下参数  
            super(16,0.75f,true);  
            //传入指定的缓存最大容量  
            this.capacity=capacity;  
        }  
        //实现LRU的关键方法，如果map里面的元素个数大于了缓存最大容量，则删除链表的顶端元素  
        @Override  
        public boolean removeEldestEntry(Map.Entry<K, V> eldest){   
            System.out.println(eldest.getKey() + "=" + eldest.getValue());    
            return size()>capacity;  
        }    
    }  

总结：感觉LinkedHashMap用模版模式，很多方法在父类HashMap中有调用，但是没有做具体实现，而是在LinkedHashMap中实现，进而实现其功能。LinkedHashMap通过重写newNode实现访问顺序的记录，重写afterNodeAccess实现对访问顺序的记录，重写afterNodeInsertion实现新元素增加后的控制（如实现LRU的删除老的节点）。

引用：
http://uule.iteye.com/blog/1522291
http://www.open-open.com/lib/view/open1410490776680.html