获取LinkedHashMap中的头部元素（最早添加的元素）：时间复杂度O(1)

public <K, V> Entry<K, V> getHead(LinkedHashMap<K, V> map) {
    return map.entrySet().iterator().next();
获取LinkedHashMap中的末尾元素（最近添加的元素）：时间复杂度O(n)
 
public <K, V> Entry<K, V> getTail(LinkedHashMap<K, V> map) {
    Iterator<Entry<K, V>> iterator = map.entrySet().iterator();
    Entry<K, V> tail = null;
    while (iterator.hasNext()) {
        tail = iterator.next();
    return tail;
通过反射获取LinkedHashMap中的末尾元素：时间复杂度O(1)，访问tail属性
 
public <K, V> Entry<K, V> getTailByReflection(LinkedHashMap<K, V> map)
        throws NoSuchFieldException, IllegalAccessException {
    Field tail = map.getClass().getDeclaredField("tail");
    tail.setAccessible(true);
    return (Entry<K, V>) tail.get(map);
import static org.junit.Assert.assertEquals;
import java.lang.reflect.Field;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import org.junit.Before;
import org.junit.Test;
public class TestLinkedHashMap {
    private LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
    private String letters[] = { "a", "b", "c", "d", "e" };
    @Before
    public void init() {
        for (int i = 0; i < letters.length; i++) {
            map.put(letters[i], i + 1);
    @Test
    public void testGetHead() {
        assertEquals(getHead(map).getKey(), "a");
        assertEquals(getHead(map).getValue(), Integer.valueOf(1));
    @Test
    public void testGetTail() {
        assertEquals(getTail(map).getKey(), "e");
        assertEquals(getTail(map).getValue(), Integer.valueOf(5));
    @Test
    public void testGetTailByReflection() throws NoSuchFieldException, IllegalAccessException {
        assertEquals(getTailByReflection(map).getKey(), "e");
        assertEquals(getTailByReflection(map).getValue(), Integer.valueOf(5));
    public <K, V> Entry<K, V> getHead(LinkedHashMap<K, V> map) {
        return map.entrySet().iterator().next();
    public <K, V> Entry<K, V> getTail(LinkedHashMap<K, V> map) {
        Iterator<Entry<K, V>> iterator = map.entrySet().iterator();
        Entry<K, V> tail = null;
        while (iterator.hasNext()) {
            tail = iterator.next();
        return tail;
    @SuppressWarnings("unchecked")
    public <K, V> Entry<K, V> getTailByReflection(LinkedHashMap<K, V> map)
            throws NoSuchFieldException, IllegalAccessException {
        Field tail = map.getClass().getDeclaredField("tail");
        tail.setAccessible(true);
        return (Entry<K, V>) tail.get(map);
                    获取LinkedHashMap中的头部元素（最早添加的元素）：时间复杂度O(1)public &lt;K, V&gt; Entry&lt;K, V&gt; getHead(LinkedHashMap&lt;K, V&gt; map) {    return map.entrySet().iterator().next();}获取LinkedHashMap中的末尾元素（最近添加的元素）：时间复杂度O(n)public &lt;K, V&gt; Entry&lt;K, V&gt; getTa
我使用了LinkedHashMap，因为重要的是键在 Map 中输入的顺序。
但是现在我想首先获得key的值(第一个输入的条目)或者最后一个。
应该有类似first()和last()之类的方法吗？
我是否需要一个迭代器来获取第一个键入口？这就是为什么我用了LinkedHashMap！
#1 热门回答(120 赞)
Link...
LinkedHashMap的内部维护了一个双向链表。可以按照元素的插入顺序进行访问，也可以按照元素的访问顺序进行访问。要注意一点的是LinkedHashMap是可以实现LRU缓存策略的，前提是你需要将LinkedHashMap中的accessorder属性设置为true。
因此你基本可以认为LinkedHashMap是LinkedList和HashMap的一个组合。
LinkedHashMap简介
LinkedHashMap继承自HashMap，拥有
				
LinkedHashMap可保证通过keySet()、entrySet()、forEach()等方法获取的元素具有顺序性，顺序分为两种：
- 添加顺序：获取元素的顺序与其被添加的顺序一致。
- 访问顺序：按元素被访问的时间进行排序，越近被访问的排在越后面，put和get等方法都表示访问。
在LinkedHashMap通过成员变量accessOrder来决定按哪种顺序排序，默认为false添加顺序，只有通过下面这个构造方法在创建LinkedHashMap时将accessOrder设置为true，才表示访问顺
public <K, V> Entry<K, V> getHead(LinkedHashMap<K, V> map) {
    return map.entrySet().iterator().next();
获取LinkedHashMap中的末尾元素（最近添加的元素）：时间复杂度O(n)
public <K, V> Entry<K, V> ge.
Map&lt;Integer, Integer&gt; map = new LinkedHashMap&lt;&gt;();            
Field tail = map.getClass().getDeclaredField("tail");
            tail.setAccessible(...
   @Test
    public void test_LinkedHashMap_findFirstKey(){
        LinkedHashMap<String,String> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("1","1");
        linkedHashMap.put("2","2”);
        // 关键代码
				
深入浅出LinkedHashMap
​	可以看做是HashMap+LinkedList，它即使用HashMap操作数据结构，又使用LinkedList维护插入元素的先后顺序，内部采用双向的形式将所有元素连接起来。
迭代有序
比HashMap多了一个双向链表的维护，大多数方法都由HashMap实现了。
底层是散列表加双向链表
插入的顺序是有序的（底层链表导致有序）
可以用来实现最近LRU算法，是页面置换算法常用的一种。
提供了map应用的算法，允许为null，不同步，可以调用Collection来实现