public LinkedHashMap(int initialCapacity, float loadFactor) {super(initialCapacity, loadFactor);accessOrder = false;}
public LinkedHashMap(int initialCapacity) {super(initialCapacity);accessOrder = false;}
public LinkedHashMap() {super();accessOrder = false;}
public LinkedHashMap(Map<? extends K, ? extends V> m) {super();accessOrder = false;putMapEntries(m, false);}
public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder) {super(initialCapacity, loadFactor);this.accessOrder = accessOrder;}

/*** Returns <tt>true</tt> if this map should remove its eldest entry.* This method is invoked by <tt>put</tt> and <tt>putAll</tt> after* inserting a new entry into the map.  It provides the implementor* with the opportunity to remove the eldest entry each time a new one* is added.  This is useful if the map represents a cache: it allows* the map to reduce memory consumption by deleting stale entries.** <p>Sample use: this override will allow the map to grow up to 100* entries and then delete the eldest entry each time a new entry is* added, maintaining a steady state of 100 entries.* <pre>*     private static final int MAX_ENTRIES = 100;**     protected boolean removeEldestEntry(Map.Entry eldest) {*        return size() &gt; MAX_ENTRIES;*     }* </pre>** <p>This method typically does not modify the map in any way,* instead allowing the map to modify itself as directed by its* return value.  It <i>is</i> permitted for this method to modify* the map directly, but if it does so, it <i>must</i> return* <tt>false</tt> (indicating that the map should not attempt any* further modification).  The effects of returning <tt>true</tt>* after modifying the map from within this method are unspecified.** <p>This implementation merely returns <tt>false</tt> (so that this* map acts like a normal map - the eldest element is never removed).** @param    eldest The least recently inserted entry in the map, or if*           this is an access-ordered map, the least recently accessed*           entry.  This is the entry that will be removed it this*           method returns <tt>true</tt>.  If the map was empty prior*           to the <tt>put</tt> or <tt>putAll</tt> invocation resulting*           in this invocation, this will be the entry that was just*           inserted; in other words, if the map contains a single*           entry, the eldest entry is also the newest.* @return   <tt>true</tt> if the eldest entry should be removed*           from the map; <tt>false</tt> if it should be retained.*/protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {return false;}

public class Demo {static class MyMap<k,v> extends LinkedHashMap<k,v>{    //定义一个继承LinkedHashMap的类，并重写removeEldestEntry方法int size;public MyMap (int size){        //只提供一个有参的构造方法，用来设置map的大小/** 这里调用的是LinkedHashMap的LinkedHashMap(int initialCapacity,boolean accessOrder)* 构造方法，设置按访问顺序排序*/super(16,0.75f,true);        this.size = size;}@Overrideprotected boolean removeEldestEntry(Entry<k, v> eldest) {// TODO Auto-generated method stubreturn this.size<size();    //设置当map里面存放的元素超过MyMap设置的size时就删除最老的元素
        }}public static void main(String[] args) {Map<String,String> map = new MyMap<String,String>(5);    for (int i = 0; i < 10; i++) {map.put(i+"", i+"");System.out.print(i+"="+map.size()+"\t");}System.out.println();//遍历map看看里面的元素map.forEach((k,v)->{System.out.println("k="+k);});//此时访问一下里面的元素，再观察遍历后的顺序map.get("6");map.get("8");System.out.println("========================");map.forEach((k,v)->{System.out.println("k="+k);});}
}

打印的结果：　　

0=1 1=2 2=3 3=4 4=5 5=5 6=5 7=5 8=5 9=5
k=5
k=6
k=7
k=8
k=9
========================
k=5
k=7
k=9
k=6
k=8