最近正好在复习数据结构的知识，顺带看了下jdk 1.8中的LinkedList和LinkedHashMap以及android中常用的LruCache的源码（内部采用LinkedHashMap实现），以加强自己的理解，下面就分享一下我阅读源码的一些简单的心得。
一、简单高效的双链表LinkedList
为什么使用双链表而不使用单链表，原因应该是，作为一种需要频繁在表头或表尾进行插入或删除操作的数据结构，选用双链表的效率会比单链表要高。试想一下，如果要删除单链表的表尾节点，除了需要将最后一个节点置空，还需要将该节点的上一个节点的next域置为null，因为此时无法直接通过最后一个节点得到倒数第二个节点的位置，所以只能重新从表头开始遍历，时间复杂度为O（n），而如果是双链表的话，可以直接通过最后一个节点的prev域即前驱节点得到它上一个节点，然后再将其next域置空，时间复杂度为O（1）。所以，双链表的优势就是，增加或删除节点的速度较快，尤其是在表尾节点。
源码
先来看下节点类的定义
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}很简单，Node类是一个静态内部类，包含了数据部分和两个引用，分别指向前驱节点和后继节点，在节点类构造的时候分别指定它的前驱节点，数据域和后继节点。这样的构造函数，在后面进行插入或删除操作的时候给我们省去了很多麻烦。
在表头插入
/**
* Links e as first element.
*/
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}我们来分析一下，也不是很复杂，first是LinkedList的成员变量，即链表的头指针，该方法首先先保存原来的头结点，赋值给一个新的Node类f，然后创建新的节点，数据为e，前驱节点为null（因为要做新的第一个嘛），后继节点是f，接着将头指针指向新创建的节点。这样就成功地将新节点插入到了原头结点的前面，但由于是双链表，插入删除时需要调整两部分的指针，我们还要将原来头结点（f）的prev域设为新的头结点，在这之前，先判断一下原来的头结点是不是为null，如果为null的话，说明原来的双链表是空表，现在插入的是第一个节点，所以last尾指针也设为newNode。最后增加链表的size。
在表尾插入
/**
* Links e as last element.
*/
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}与在表头插入很类似，先保存原先尾节点的值为l，然后创建新的尾节点插入到l后面，然后调整原先尾节点l的next域，指向新的尾节点。在这之前同样先判断一下是不是空表，是空表的话，插入一个节点后first头结点也指向newNode。
在一个节点之前插入
/**
* Inserts element e before non-null Node succ.
*/
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}该方法将一个新节点插入到succ节点前面。逻辑也很清晰，首先先获取到succ的前驱节点pred，然后新创建一个节点插入到pred和succ两者之间，然后分别修改succ的prev域和pred的next域，都指向新的节点。同样的，在修改pred的next域之前，判断pred是否为空，如果为空，说明原来succ是头结点，所以要把头指针指向新创建的节点newNode。
在表头删除
/**
* Unlinks non-null first node f.
*/
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}在删除表头节点f的时候，先保存其下一个节点next，接着将f的数据域和指针域强制置为null，这样可以帮助垃圾收集器GC很快的回收这两个引用。跟着将新的头指针指向next，然后判断next是否为空，如果next为空，说明原来只有一个节点，删除后表变空了，所以将last也设为null，否则的话将next（此时的新头结点）的prev前驱指针设为null，最后修改表的长度大小，并将删除的头结点的值返回。
在表尾删除
/**
* Unlinks non-null last node l.
*/
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
final E element = l.item;
final Node<E> prev = l.prev;
l.item = null;
l.prev = null; // help GC
last = prev;
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}逻辑与上面在表头删除正好相反，就不在赘述了。
在表中删除
/**
* Unlinks non-null node x.
*/
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}从双链表中删除指定结点x，首先获得x的前驱和后继节点，如果前驱节点为null，说明x为头结点，删除后直接将头指针指向x的后继节点，如果不是头结点则将x的前驱节点的后继指向x的后继，并将x的前驱置为空，将x从链中断开，此处画个图就很好理解；接着同样判断x的后继next是不是空，如果是空说明x是尾节点，要删除的话则直接将尾指针指向x的前驱，否则修改x后继节点的前驱指针，指向x的前驱，再把x的next置为null，将x从链中断开。
我们常用的一些add和remove操作，调用的都是上面的函数。
public boolean add(E e) {
linkLast(e);
return true;
}public void addFirst(E e) {
linkFirst(e);
} public void addLast(E e) {
linkLast(e);
}
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}public void push(E e) {
addFirst(e);
} public E pop() {
return removeFirst();
}如果你理解了双链表的基本插入删除操作，那么LinkedList的源码你也可以差不多基本理解了，剩下的一些细节我就不再说了，下面看LinkedHashMap。
二、LinkedHashMap
LinkedHashMap是HashMap的子类，通俗的讲就是加了双链表结构的HashMap。HashMap大家都很清楚，本质就是Entry数组加链表（或者红黑树）的形式，Entry这个数据结构包括hash值，key-value键值对，和next索引（通过链地址法用来解决哈希冲突）。而我们看看LinkedHashMap里的Entry
LinkedHashMap的Entry
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}可以看到LinkedHashMap在原来HashMap的Entry的基础上又增加了before和after两个指针（java中只有引用，这里说指针是为了方便理解），分别指向前驱和后继节点，所以说，它是一个完完全全的双链表+HashMap。
双链表表头与表尾的定义
/**
* The head (eldest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> head;
/**
* The tail (youngest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> tail;还有一个很重要的成员变量accessOrder
final boolean accessOrder;如果accessOrder为true表明LinkedHashMap按照访问的顺序来迭代，如果为false表明LinkedHashMap按照插入的顺序来迭代。默认是按照插入顺序来遍历：
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}在创建新节点的时候，是直接将Entry加入到双链表的尾部：
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);
linkNodeLast(p);
return p;
}下面我们就来看一下这个linkNodeLast（）方法
// link at the end of list
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;
tail = p;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
}linkNodeLast方法将一个Entry节点加入到双链表的尾部。首先保存原双链表的表尾节点tail为last，然后将tail指向新插入的节点p，此时判断原来的表尾节点last是否为null，如果为null，说明原来双链表为空表，插入后只有一个节点，所以将head头指针也指向p，否则的话，将p的前驱指向原来的表尾节点last，将原来表尾节点last的后继指向新的表尾节点p。
细想一下，和LinkedList那段是不是很像？没错，因为归根结底还是双链表的插入操作。
下面看一下LinkedHashMap的get()方法
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}可以看到，在访问完一个节点后，如果accessOrder为true的话（即设置按照访问顺序来迭代），会调用afterNodeAccess()函数将刚访问过的节点放置到双链表的尾部，即放到最新的位置，代表这个节点刚被访问过。我们再去afterNodeAccess()函数看看究竟
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
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) //如果p是表头
head = a; //将e从表中断开后，表头指向e的后继
else
b.after = a; //否则将e从表中断开
if (a != null)
a.before = b;
else //p是表尾
last = b; //将e从表中断开后，表尾指向e的前驱
if (last == null) //如果原链表是空表
head = p; //表头指向p
else { //否则插向原链表的表尾
p.before = last;
last.after = p;
}
tail = p; //尾节点指向新插入的节点
++modCount;
}
}该函数将节点e从原双链表中摘下，并插入到最后的位置。这里还是先用一个last来保存原来的tail表尾节点，如果accessOrder为true，并且此时节点p（由e转换而来）并不在表尾，则执行后面的操作，后面的操作可以分为两部分，第一部分是将节点p从原来双链表的位置中断开，第二部分是将节点p插入到表尾。和之前在LinkedList中的操作很类似，将节点p从原链表中删除时，判断了p是否在表头或是在表尾（与LinkedList的unlinkFirst和unlinkLast函数相同）；将p插入到链表尾部时，加入了表是否为空的判断（与LinkedList的linkLast函数相同）。
综上，我们可以看到，将LinkedList中双链表的增加和删除操作与HashMap相结合，就是LinkedHashMap。
三、LruCache
理解了LinkedHashMap，就不难理解LruCache的实现原理了。这个Android中最常用的缓存类，内部就维护了一个LinkedHashMap的引用
private final LinkedHashMap<K, V> map;在 LruCache初始化时，指定了hasmap的扩容因子，并设置accessOrder为true，按访问顺序迭代，来达到LRU（最近最久未使用）算法的效果：最近被访问的，或者最新插入的，总是在表尾，而不怎么被经常访问的，就会逐渐向表头移动，此时就可以从表头将这些不常用的缓存淘汰。
我们来看一下从缓存中取数据的get方法
public final V get(K key) {
if (key == null) {
throw new NullPointerException("key == null");
}
V mapValue;
synchronized (this) {
// 如果根据相应的key能查找到value，就增加一次缓存命中的次数hitCount，并且返回结果
mapValue = map.get(key);
if (mapValue != null) {
hitCount++;
return mapValue;
}
// 否则增加一次未命中次数missCount
missCount++;
}
/*
* Attempt to create a value. This may take a long time, and the map
* may be different when create() returns. If a conflicting value was
* added to the map while create() was working, we leave that value in
* the map and release the created value.
*/
V createdValue = create(key);
if (createdValue == null) {
return null;
}
synchronized (this) {
createCount++;
// 如果我们重写了create(key)方法而且返回值不为空，那么将上述的key与这个返回值写入到map当中
mapValue = map.put(key, createdValue);
if (mapValue != null) {
// There was a conflict so undo that last put
// 方法放入最后put的key，value值
map.put(key, mapValue);
} else {
size += safeSizeOf(key, createdValue);
}
}
if (mapValue != null) {
// 这个方法也可以重写
entryRemoved(false, key, createdValue, mapValue);
return mapValue;
} else {
trimToSize(maxSize);
return createdValue;
}
}下面再看一下LruCache更新缓存的策略，主要在trimToSize()这个函数中
/**
* 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 (true) {
K key;
V value;
synchronized (this) {
if (size < 0 || (map.isEmpty() && size != 0)) {
throw new IllegalStateException(getClass().getName()
+ ".sizeOf() is reporting inconsistent results!");
}
if (size <= maxSize || map.isEmpty()) {
break;
}
//按照访问顺序来迭代，最新访问过的都在表尾，表头的是最近长时间内都没有使用过的缓存
Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
key = toEvict.getKey();
value = toEvict.getValue();
//将缓存移除
map.remove(key);
//修改缓存链表的size
size -= safeSizeOf(key, value);
//淘汰掉一个缓存
evictionCount++;
}
entryRemoved(true, key, value, null);
}
}从注释中就可以看到，这个函数将最老的也就是最久没有访问过的entry删除，以将整体entry的容量降低到指定大小（淘汰了最近不常用的缓存）。可以看到，它通过map.entrySet().iterator()获得LinkedHashMap的迭代器，从保存了缓存数据的双链表的第一个节点开始（即最久没有使用过的缓存，因为最近刚使用过的缓存都移到了表尾），逐个调用remove函数，将其从表中删除，以降低整体缓存的大小。
看到了这里，是不是对LinkedList，LinkedHashMap，LruCache的基本原理有了一个清楚的认识呢？我们看到，万变不离其宗，其重点就是围绕双链表的增删改操作，数据结构的基础确实很重要。