/**

      * LinkedHashMap entry.

      */

     private static class Entry<K,V> extends HashMap.Entry<K,V> {

         // These fields comprise the doubly linked list used for iteration.

         // 双向链表的上一个节点before和下一个节点after

         Entry<K,V> before, after ;

        // 构造方法直接调用父类HashMap的构造方法（super）

        Entry( int hash, K key, V value, HashMap.Entry<K,V> next) {

             super(hash, key, value, next);

         }

         /**

          * 从链表中删除当前节点的方法

          */

         private void remove() {

             // 改变当前节点前后两个节点的引用关系，当前节点没有被引用后，gc可以回收

             // 将上一个节点的after指向下一个节点

             before.after = after;

             // 将下一个节点的before指向前一个节点

             after.before = before;

         }

         /**

          * 在指定的节点前加入一个节点到链表中（也就是加入到链表尾部）

          */

         private void addBefore(Entry<K,V> existingEntry) {

             // 下面改变自己对前后的指向

             // 将当前节点的after指向给定的节点（加入到existingEntry前面嘛）

             after  = existingEntry;

             // 将当前节点的before指向给定节点的上一个节点

             before = existingEntry.before ;

             // 下面改变前后最自己的指向

             // 上一个节点的after指向自己

             before.after = this;

             // 下一个几点的before指向自己

             after.before = this;

         }

         // 当向Map中获取查询元素或修改元素（put相同key）的时候调用这个方法

         void recordAccess(HashMap<K,V> m) {

             LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;

             // 如果accessOrder为true，也就是使用最近较少使用顺序

             if (lm.accessOrder ) {

                 lm. modCount++;

                 // 先删除，再添加，也就相当于移动了

                 // 删除当前元素

                 remove();

                 // 将当前元素加入到header前（也就是链表尾部）

                 addBefore(lm. header);

             }

         }

         // 当从Map中删除元素的时候调动这个方法

         void recordRemoval(HashMap<K,V> m) {

             remove();

         }

 }

 /**

      * Constructs an empty <tt>HashMap</tt> with the specified initial

      * capacity and load factor.

      *

      * @param  initialCapacity the initial capacity

      * @param  loadFactor      the load factor

      * @throws IllegalArgumentException if the initial capacity is negative

      *         or the load factor is nonpositive

      */

     public HashMap( int initialCapacity, float loadFactor) {

         if (initialCapacity < 0)

             throw new IllegalArgumentException( "Illegal initial capacity: " +

                                                initialCapacity);

         if (initialCapacity > MAXIMUM_CAPACITY)

             initialCapacity = MAXIMUM_CAPACITY;

         if (loadFactor <= 0 || Float.isNaN(loadFactor))

             throw new IllegalArgumentException( "Illegal load factor: " +

                                                loadFactor);

         // Find a power of 2 >= initialCapacity

         int capacity = 1;

         while (capacity < initialCapacity)

             capacity <<= 1;

         this.loadFactor = loadFactor;

         threshold = (int)(capacity * loadFactor);

         table = new Entry[capacity];

         init();

     }

     /**

      * Initialization hook for subclasses. This method is called

      * in all constructors and pseudo -constructors (clone, readObject)

      * after HashMap has been initialized but before any entries have

      * been inserted.  (In the absence of this method, readObject would

      * require explicit knowledge of subclasses.)

      */

     void init() {
     

     /**

      * Called by superclass constructors and pseudoconstructors (clone,

      * readObject) before any entries are inserted into the map.  Initializes

      * the chain.

      */

     void init() {

         // 初始化话header，将hash设置为-1，key、value、next设置为null

         header = new Entry<K,V>(-1, null, null, null);

         // header的before和after都指向header自身

         header.before = header. after = header ;
     

 import java.util.LinkedHashMap;

 import java.util.Map;

 public class MyLocalCache extends LinkedHashMap<String, Object> {

         private static final long serialVersionUID = 7182816356402068265L;

         private static final int DEFAULT_MAX_CAPACITY = 1024;

         private static final float DEFAULT_LOAD_FACTOR = 0.75f;

         private int maxCapacity;

         public enum Policy {

                FIFO, LRU

        }

         public MyLocalCache(Policy policy) {

                super(DEFAULT_MAX_CAPACITY, DEFAULT_LOAD_FACTOR, Policy.LRU .equals(policy));

                this.maxCapacity = DEFAULT_MAX_CAPACITY;

        }

         public MyLocalCache(int capacity, Policy policy) {

                super(capacity, DEFAULT_LOAD_FACTOR, Policy. LRU.equals(policy));

                this.maxCapacity = capacity;

        }

         @Override

         protected boolean removeEldestEntry(Map.Entry<String, Object> eldest) {

                return this.size() > maxCapacity;

        }

         public static void main(String[] args) {

               MyLocalCache cache = new MyLocalCache(5, Policy.LRU);

               cache.put( "k1", "v1" );

               cache.put( "k2", "v2" );

               cache.put( "k3", "v3" );

               cache.put( "k4", "v4" );

               cache.put( "k5", "v5" );

               cache.put( "k6", "v6" );

               System. out.println("size=" + cache.size());

               System. out.println("----------------------" );

                for (Map.Entry<String, Object> entry : cache.entrySet()) {

             　　　　System. out.println(entry.getValue());

         　　　　}

               System. out.println("----------------------" );

               System. out.println("k3=" + cache.get("k3"));

               System. out.println("----------------------" );

                for (Map.Entry<String, Object> entry : cache.entrySet()) {

             　　　　System. out.println(entry.getValue());

         　　　　}

        }

 }