应用场景
HashMap是无序的，当我们希望有顺序地去存储key-value时，就需要使用LinkedHashMap了。
Map<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("name1", "josan1");
linkedHashMap.put("name2", "josan2");
linkedHashMap.put("name3", "josan3");
Set<Map.Entry<String, String>> set = linkedHashMap.entrySet();
Iterator<Map.Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext()) {
Map.Entry entry = iterator.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + " ,value:" + value);
}
输出结果：
key:name1 ,value:josan1
key:name2 ,value:josan2
key:name3 ,value:josan3
结果可知，LinkedHashMap是有序的，且默认为插入顺序。
LinkedHashMap特点
先总体看一下特点，后面会根据源码来分析这些特点。
1、能够保证存储元素的顺序。深入一点讲，有两种迭代元素的方式，一种是按照插入元素时的顺序迭代，比如，插入A,B,C，那么迭代也是A,B,C，另一种是按照访问顺序，比如，在迭代前，访问了B，那么迭代的顺序就是A,C,B，比如在迭代前，访问了B，接着又访问了A，那么迭代顺序为C,B,A，比如，在迭代前访问了B，接着又访问了B，然后在访问了A，迭代顺序还是C,B,A。要说明的意思就是：不是近期访问的次数最多，就放最后面迭代，而是最近访问的就放最后面迭代。
2、内部存储的元素的模型。Entry是下面这样的，相比HashMap，多了两个属性，一个before，一个after。next和after有时候会指向同一个entry，有时候next指向null，而after指向entry。这个具体后面分析。
3、LinkedHashMap和HashMap在存储操作上是一样的，但是LinkedHashMap多的东西是会记住在此之前插入的元素，LinkedHashMap存储结构图：
也就是说，对于LinkedHashMap的基本操作还是和HashMap一样，但是在其上面加了两个属性，也就是为了记录前一个插入的元素和记录后一个插入的元素。只要和hashmap一样进行操作之后把这两个属性的值设置好，就可以了。注意一点，会有一个header的实体，目的是为了记录第一个插入的元素，在遍历的时候能够找到第一个元素。
实际上存储的样子就像上面这个图一样，存储方式和hashMap一样，但是增加了一个双向循环链表。就是因为有了这个双向循环链表，LinkedHashMap才和HashMap不一样。
构造方法
LinkedHashMap提供了多个构造方法，我们先看空参的构造方法。
public LinkedHashMap() {
// 调用HashMap的构造方法
super();
// accessOrder指是否基于访问排序，默认为false表示按照插入顺序排序
accessOrder = false;
}
LinkedHashMap存储数据是有序的，而且分为两种：插入顺序和访问顺序。
这里accessOrder设置为false，表示不是按照访问顺序而是按照插入顺序存储的，这也是默认值，表示LinkedHashMap中存储的顺序是按照调用put方法插入的顺序进行排序的。
LinkedHashMap也提供了可以设置accessOrder的构造方法，我们来看看设置accessOrder为true这种模式下，它的顺序有什么特点？
// 第三个参数用于指定accessOrder值
Map<String, String> linkedHashMap = new LinkedHashMap<>(16, 0.75f, true);
linkedHashMap.put("name1", "josan1");
linkedHashMap.put("name2", "josan2");
linkedHashMap.put("name3", "josan3");
System.out.println("开始时顺序：");
Set<Entry<String, String>> set = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext()) {
Entry entry = iterator.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
}
System.out.println("通过get方法，导致key为name1对应的Entry到表尾");
linkedHashMap.get("name1");
Set<Entry<String, String>> set2 = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator2 = set2.iterator();
while(iterator2.hasNext()) {
Entry entry = iterator2.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
}
输出结果：
开始时顺序：
key:name1,value:josan1
key:name2,value:josan2
key:name3,value:josan3
通过get方法，导致key为name1对应的Entry到表尾
key:name2,value:josan2
key:name3,value:josan3
key:name1,value:josan1
还记得，HashMap解析中提到，在HashMap的构造函数中，调用了init方法，而在HashMap中init方法是空实现，但LinkedHashMap重写了该方法，所以在LinkedHashMap的构造方法里，调用了自身的init方法，init的重写实现如下：
/**
* Called by superclass constructors and pseudoconstructors (clone,
* readObject) before any entries are inserted into the map. Initializes
* the chain.
*/
@Override
void init() {
// 创建了一个hash=-1，key、value、next都为null的Entry
header = new Entry<>(-1, null, null, null);
// 让创建的Entry的before和after都指向自身，注意after不是之前提到的next
// 其实就是创建了一个只有头部节点的双向链表
header.before = header.after = header;
}
这好像跟我们上一篇HashMap提到的Entry有些不一样，HashMap中静态内部类Entry是这样定义的：
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
没有before和after属性啊！原来，LinkedHashMap有自己的静态内部类Entry，它继承了HashMap.Entry，定义如下:
/**
* LinkedHashMap entry.
*/
private static class Entry<K,V> extends HashMap.Entry<K,V> {
// These fields comprise the doubly linked list used for iteration.
Entry<K,V> before, after;
Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
super(hash, key, value, next);
}
所以LinkedHashMap构造函数，主要就是调用HashMap构造函数初始化了一个Entry[] table，然后调用自身的init初始化了一个只有头结点的双向链表。完成了如下操作：
put方法
LinkedHashMap没有重写put方法，所以还是调用HashMap的put方法，如下：
public V put(K key, V value) {
// 对key为null的处理
if (key == null)
return putForNullKey(value);
// 计算hash
int hash = hash(key);
// 得到在table中的index
int i = indexFor(hash, table.length);
// 遍历table[index]，判断key是否已经存在，存在则替换，并返回旧值
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
// 如果key之前在table中不存在，则调用addEntry，LinkedHashMap重写了该方法
addEntry(hash, key, value, i);
return null;
}
我们看看LinkedHashMap的addEntry方法：
void addEntry(int hash, K key, V value, int bucketIndex) {
// 调用父类的addEntry，增加一个Entry到HashMap中
super.addEntry(hash, key, value, bucketIndex);
// removeEldestEntry方法默认返回false，不用考虑
Entry<K,V> eldest = header.after;
if (removeEldestEntry(eldest)) {
removeEntryForKey(eldest.key);
}
}
这里调用了父类HashMap的addEntry方法，如下：
void addEntry(int hash, K key, V value, int bucketIndex) {
// 扩容相关
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
// LinkedHashMap进行了重写
createEntry(hash, key, value, bucketIndex);
}
前面是扩容相关的代码，在上一篇HashMap解析中已经讲过了。这里主要看createEntry方法，LinkedHashMap进行了重写。
void createEntry(int hash, K key, V value, int bucketIndex) {
HashMap.Entry<K,V> old = table[bucketIndex];
// e就是新创建了Entry，会加入到table[bucketIndex]的表头
Entry<K,V> e = new Entry<>(hash, key, value, old);
table[bucketIndex] = e;
// 把新创建的Entry，加入到双向链表中
e.addBefore(header);
size++;
}
我们来看看LinkedHashMap.Entry的addBefore方法：
private void addBefore(Entry<K,V> existingEntry) {
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}
从这里就可以看出，当put元素时，不但要把它加入到HashMap中去，还要加入到双向链表中，所以可以看出LinkedHashMap就是HashMap+双向链表，下面用图来表示逐步往LinkedHashMap中添加数据的过程，红色部分是双向链表，黑色部分是HashMap结构，header是一个Entry类型的双向链表表头，本身不存储数据。
首先是只加入一个元素Entry1，假设index为0：
当再加入一个元素Entry2，假设index为15：
当再加入一个元素Entry3, 假设index也是0：
以上，就是LinkedHashMap的put的所有过程了，总体来看，跟HashMap的put类似，只不过多了把新增的Entry通过before和after指针加入到双向链表中的过程。
也就是说，对于LinkedHashMap的基本操作还是和HashMap一样，但是在其上面加了两个属性，也就是为了记录前一个插入的元素和记录后一个插入的元素，只要和hashmap一样进行操作之后把这两个属性的值设置好，就可以了。注意一点，会有一个header的Entry，目的是为了记录第一个插入的元素，在遍历的时候能够找到第一个元素。
双向链表的重排序
前面分析的，主要是当前LinkedHashMap中不存在当前key时，新增Entry的情况。当key如果已经存在时，则进行更新Entry的value。就是HashMap的put方法中的如下代码：
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
// 重排序
e.recordAccess(this);
return oldValue;
}
}
主要看e.recordAccess(this)，这个方法跟访问顺序有关，而HashMap是无序的，所以在HashMap.Entry的recordAccess方法是空实现，但是LinkedHashMap是有序的，LinkedHashMap.Entry对recordAccess方法进行了重写。
void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
// 如果LinkedHashMap的accessOrder为true，则进行重排序
// 比如前面提到LruCache中使用到的LinkedHashMap的accessOrder属性就为true
if (lm.accessOrder) {
lm.modCount++;
// 把更新的Entry从双向链表中移除
remove();
// 再把更新的Entry加入到双向链表的表尾
addBefore(lm.header);
}
}
在LinkedHashMap中，只有accessOrder为true，即是访问顺序的模式，才会put时对更新的Entry进行重新排序，而如果是插入顺序模式时，不会重新排序，这里的排序跟在HashMap中的存储没有关系，只是指在双向链表中的顺序。
举个例子：
开始时，HashMap中有Entry1、Entry2、Entry3，并设置LinkedHashMap为访问顺序，则更新Entry1时，会先把Entry1从双向链表中删除，然后再把Entry1加入到双向链表的表尾，而Entry1在HashMap结构中的存储位置没有变化，对比图如下所示：
get方法
LinkedHashMap有对get方法进行了重写，如下：
public V get(Object key) {
// 调用genEntry得到Entry
Entry<K,V> e = (Entry<K,V>)getEntry(key);
if (e == null)
return null;
// 如果LinkedHashMap是访问顺序的，则get时，也需要重新排序
e.recordAccess(this);
return e.value;
}
先是调用了getEntry方法，通过key得到Entry，而LinkedHashMap并没有重写getEntry方法，所以调用的是HashMap的getEntry方法，在上一篇文章中我们分析过HashMap的getEntry方法：首先通过key算出hash值，然后根据hash值算出在table中存储的index，然后遍历table[index]的单向链表去对比key，如果找到了就返回Entry。
后面调用了LinkedHashMap.Entry的recordAccess方法，上面分析过put过程中这个方法，其实就是在访问顺序的LinkedHashMap进行了get操作以后，重新排序，把get的Entry移动到双向链表的表尾。
遍历方式取数据
我们先来看看HashMap使用遍历方式取数据的过程：
很明显，这样取出来的Entry顺序肯定跟插入顺序不同了，既然LinkedHashMap是有序的，那么它是怎么实现的呢？
先看看LinkedHashMap遍历方式获取数据的代码：
Map<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("name1", "josan1");
linkedHashMap.put("name2", "josan2");
linkedHashMap.put("name3", "josan3");
// LinkedHashMap没有重写该方法，调用的HashMap中的entrySet方法
Set<Entry<String, String>> set = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext()) {
Entry entry = iterator.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
}
LinkedHashMap没有重写entrySet方法，我们先来看HashMap中的entrySet，如下：
public Set<Map.Entry<K,V>> entrySet() {
return entrySet0();
}
private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return newEntryIterator();
}
// 无关代码
......
}
可以看到，HashMap的entrySet方法，其实就是返回了一个EntrySet对象。
我们得到EntrySet会调用它的iterator方法去得到迭代器Iterator，从上面的代码也可以看到，iterator方法中直接调用了newEntryIterator方法并返回，而LinkedHashMap重写了该方法：
Iterator<Map.Entry<K,V>> newEntryIterator() {
return new EntryIterator();
}
这里直接返回了EntryIterator对象，这个和上一篇HashMap中的newEntryIterator方法中一模一样，都是返回了EntryIterator对象，其实他们返回的是各自的内部类。我们来看看LinkedHashMap中EntryIterator的定义：
private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}
该类是继承LinkedHashIterator（而HashMap中是继承HashIterator），并重写了next方法；
我们再来看看LinkedHashIterator的定义：
private abstract class LinkedHashIterator<T> implements Iterator<T> {
// 默认下一个返回的Entry为双向链表的表头header的下一个元素
Entry<K,V> nextEntry = header.after;
Entry<K,V> lastReturned = null;
public boolean hasNext() {
return nextEntry != header;
}
Entry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (nextEntry == header)
throw new NoSuchElementException();
Entry<K,V> e = lastReturned = nextEntry;
nextEntry = e.after;
return e;
}
// 不相关代码
......
}
我们先不看整个类的实现，只要知道在LinkedHashMap中，Iterator<Entry<String, String>> iterator = set.iterator()，这段代码会返回一个继承LinkedHashIterator的Iterator，它有着跟HashIterator不一样的遍历规则。
接着，我们会用while(iterator.hasNext())去循环判断是否有下一个元素，LinkedHashMap中的EntryIterator没有重写LinkedHashIterator的该方法，所以还是调用LinkedHashIterator中的hasNext方法，如下：
public boolean hasNext() {
// 下一个应该返回的Entry是否就是双向链表的头结点
// 有两种情况：1.LinkedHashMap中没有元素；2.遍历完双向链表回到头部
return nextEntry != header;
}
nextEntry表示下一个应该返回的Entry，默认值是header.after，即双向链表表头的下一个元素。而上面介绍到，LinkedHashMap在初始化时，会调用init方法去初始化一个before和after都指向自身的Entry，但是put过程会把新增加的Entry加入到双向链表的表尾，所以只要LinkedHashMap中有元素，第一次调用hasNext肯定不会为false。
然后我们会调用next方法去取出Entry，LinkedHashMap中的EntryIterator重写了该方法，如下：
public Map.Entry<K,V> next() {
return nextEntry();
}
而它自身又没有重写nextEntry方法，所以还是调用的LinkedHashIterator中的nextEntry方法：
Entry<K,V> nextEntry() {
// 保存应该返回的Entry
Entry<K,V> e = lastReturned = nextEntry;
//把当前应该返回的Entry的after作为下一个应该返回的Entry
nextEntry = e.after;
// 返回当前应该返回的Entry
return e;
}
这里其实遍历的是双向链表，所以不会存在HashMap中需要寻找哈希桶中下一条单链表的情况，从头结点Entry header的下一个节点开始，只要把当前返回的Entry的after作为下一个应该返回的节点即可。直到到达双向链表的尾部时，after为双向链表的表头节点Entry header，这时候hasNext就会返回false，表示没有下一个元素了。LinkedHashMap的遍历取值如下图所示：
易知，遍历出来的结果为Entry1、Entry2…Entry6。
可得，LinkedHashMap是有序的，且是通过双向链表来保证顺序的。
remove方法
LinkedHashMap没有提供remove方法，所以调用的是HashMap的remove方法，实现如下：
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
final Entry<K,V> removeEntryForKey(Object key) {
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;
// LinkedHashMap.Entry重写了该方法
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
在分析HashMap中就分析了remove过程，其实就是断开其他对象对自己的引用。比如被删除Entry是在单向链表的表头，则让它的next放到表头，这样它就没有被引用了；如果不是在表头，它是被别的Entry的next引用着，这时候就让上一个Entry的next指向它自己的next，这样，它也就没被引用了。
在HashMap.Entry中recordRemoval方法是空实现，但是LinkedHashMap.Entry对其进行了重写，如下：
void recordRemoval(HashMap<K,V> m) {
remove();
}
private void remove() {
before.after = after;
after.before = before;
}
易知，这是要把双向链表中的Entry删除，也就是要断开当前要被删除的Entry被其他对象通过after和before的方式引用。
所以，LinkedHashMap的remove操作。首先把它从table中删除，即断开table或者其他对象通过next对其引用，然后也要把它从双向链表中删除，断开其他对象通过after和before对其引用。
HashMap与LinkedHashMap的结构对比
再来看看HashMap和LinkedHashMap的结构图，是不是秒懂了。LinkedHashMap其实就是可以看成HashMap的基础上，多了一个双向链表来维持顺序。
LinkedHashMap在Android中的应用：实现LRU
在Android中使用图片时，一般会用LruCache做图片的内存缓存，它里面就是使用LinkedHashMap来实现存储的。
public class LruCache<K, V> {
private final LinkedHashMap<K, V> map;
public LruCache(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
this.maxSize = maxSize;
// 注意第三个参数，是accessOrder，这里为true，后面会讲到
this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
}
....
}
前面提到了，accessOrder为true表示LinkedHashMap为访问顺序，当对已存在LinkedHashMap中的Entry进行get和put操作时，会把Entry移动到双向链表的表尾（其实是先删除，再插入）。
我们拿LruCache的put方法举例：
public final V put(K key, V value) {
if (key == null || value == null) {
throw new NullPointerException("key == null || value == null");
}
V previous;
// 对map进行操作之前，先进行同步操作
synchronized (this) {
putCount++;
size += safeSizeOf(key, value);
previous = map.put(key, value);
if (previous != null) {
size -= safeSizeOf(key, previous);
}
}
if (previous != null) {
entryRemoved(false, key, previous, value);
}
// 整理内存，看是否需要移除LinkedHashMap中的元素
trimToSize(maxSize);
return previous;
}
之前提到了，HashMap是线程不安全的，LinkedHashMap同样是线程不安全的。所以在对调用LinkedHashMap的put方法时，先使用synchronized 进行了同步操作。
我们最关心的是倒数第一行代码，其中maxSize为我们给LruCache设置的最大缓存大小。我们看看该方法：
/**
* Remove the eldest entries until the total of remaining entries is at or
* below the requested size.
*
* @param maxSize the maximum size of the cache before returning. May be -1
* to evict even 0-sized elements.
*/
public void trimToSize(int maxSize) {
// while死循环，直到满足当前缓存大小<=最大可缓存大小
while (true) {
K key;
V value;
// 线程不安全，需要同步
synchronized (this) {
if (size < 0 || (map.isEmpty() && size != 0)) {
throw new IllegalStateException(getClass().getName()
+ ".sizeOf() is reporting inconsistent results!");
}
// 如果当前缓存的大小，已经小于等于最大可缓存大小，则直接返回
// 不需要再移除LinkedHashMap中的数据
if (size <= maxSize || map.isEmpty()) {
break;
}
// 得到的就是双向链表的表头header的下一个Entry
Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
key = toEvict.getKey();
value = toEvict.getValue();
// 移除当前取出的Entry
map.remove(key);
// 从新计算当前的缓存大小
size -= safeSizeOf(key, value);
evictionCount++;
}
entryRemoved(true, key, value, null);
}
}
从注释上就可以看出，该方法就是不断移除LinkedHashMap中双向链表的表头的元素，直到当前缓存大小<=最大可缓存的大小。
由前面的重排序我们知道，对LinkedHashMap的put和get操作，都会让被操作的Entry移动到双向链表的表尾，而remove操作是从map.entrySet().iterator().next()开始的，也就是双向链表的表头的header的after开始的，这也就符合了LRU算法的需求。
下图表示了LinkedHashMap中删除、添加、get/put已存在的Entry操作。
红色表示初始状态
紫色表示缓存图片大小超过了最大可缓存大小时，才能够表头移除Entry1
蓝色表示对已存在的Entry3进行了get/put操作，把它移动到双向链表表尾
绿色表示新增一个Entry7，插入到双向链表的表尾（暂时不考虑在HashMap中的位置）
LinkedHashMap总结
- LinkedHashMap是继承于HashMap，是基于HashMap和双向链表来实现的。
- HashMap无序；LinkedHashMap有序，可分为插入顺序和访问顺序两种。如果是按照访问顺序，那put和get操作已存在的Entry时，都会把Entry移动到双向链表的表尾(其实是先删除再插入)。
- LinkedHashMap存取数据，还是跟HashMap一样使用的Entry[]的方式，双向链表只是为了保证顺序。
- LinkedHashMap是线程不安全的。
实现LRU的各种方式的总结
相关面试题：https://leetcode-cn.com/problems/lru-cache/
实现LRU有很多种方式：
1.首先考虑的是数组，数组可以实现，但是判断缓存是否命中的时候要遍历数组，复杂度O(n)。
2.使用单链表，可以实现。淘汰元素即更新head指针即可，复杂度O(1)。加入元素即更新tail指针即可，复杂度O(1)。但是判断缓存是否命中的时候需要遍历链表，复杂度O(n)。
3.单链表+HashMap
HashMap用于定位命中的元素，不用遍历链表，复杂度O(1)。
定位命中的元素后直接将tail指针指向命中的元素，然后将命中的元素的上一个元素的指针指向下一个元素，但是如何快速定位到命中的元素的上一个元素呢？（当然不是从头开始遍历，这需要O(n)的复杂度）所以要用到双向链表！利用before指针就可以快速定位到命中的元素的上一个元素。
4.双向链表+HashMap
head指向的永远是最近最少使用的元素，即淘汰时肯定是淘汰head指向的元素，而新加入元素时加入到tail指向的元素后面即可，然后将tail指向新加入的元素。缓存命中时只需将tail指针指向命中的元素，然后将命中的元素的上一个元素的指针指向下一个元素。都是O(1)的操作。
可以用jdk中的LinkedHashMap实现双向链表+HashMap的结构，即用LinkedHashMap可以实现在O(1)的复杂度下完成缓存的get和put操作。
总结：
1.使用数组可以实现，但是无法实现O(1)
2.使用单链表可以实现，但是判断缓存是否命中的时候需要遍历链表，无法实现get元素时的O(1)
3.如果实现get元素时的O(1)，需要加上哈希表，但是缓存命中时更新命中的元素的上一个元素的指针需要O(n)的复杂度
4.如果实现在O(1)的复杂度下更新命中的元素的上一个元素的指针，需要用到双向链表。
5.最终使用：双向链表+HashMap（即JDK的LinkedHashMap）
头条面试要求：不使用JDK的LinkedHashMap，需要手写实现。
面试的时候，在手写LinkedHashMap实现了LRU后，如何更好的表现自己？
可以提供更多的思考方向：
1.哨兵写法(dummy head，dummy tail)
2.考虑如何实现线程安全(说明自己是考虑到线程安全的)，当然不是所有的方法加synchronized关键字这种粗粒度锁的方式
3.high throughput（CAS操作）
4.考虑concurrentHashMap（分段锁）
5.如果允许一定的精确性损失（读写锁，读的时候允许写）
6.当然还可以考虑下环形LRU能否实现(思路来源于Disruptor的 Ringbuffer)
7.当然还可以考虑下提前分配空间的LRU，优点是啥？这个应用场景下好像没有优点…
8.当然还可以考虑下删除的时候不删除，留着内存空间的做法
9.当然还可以考虑下分布式的LRU
…
仅仅是思考的方向，不一定切实可行，需要实践分析是否可行。但是让面试官知道了你的思考维度，展现自己。
参考：
https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html
1391
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
