Android LinkedList
1. LinkedList
①LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。
②LinkedList 实现 List 接口，能对它进行队列操作； 实现 Deque 接口，即能将LinkedList当作双端队列使用；实现了Cloneable接口，即覆盖了函数clone()，能克隆；实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
③LinkedList 是非同步的。
2.LinkedList的数据结构
先看看链表结构都有哪些：
①单向链表
element：用来存放元素
next：用来指向下一个节点元素
通过每个结点的指针指向下一个结点从而链接起来的结构，最后一个节点的next指向null。
②单向循环链表
element、next 跟前面一样。
在单向链表的最后一个节点的next会指向头节点，而不是指向null，这样存成一个环。
③双向链表
element：存放元素
pre：用来指向前一个元素
next：指向后一个元素
双向链表是包含两个指针的，pre指向前一个节点，next指向后一个节点，但是第一个节点head的pre指向null，最后一个节点的tail指向null。
④双向循环链表
element、pre、next 跟前面的一样。
第一个节点的pre指向最后一个节点，最后一个节点的next指向第一个节点，形成一个环。
LinkedList的数据结构是第三种—双向链表。
如上图所示，LinkedList底层使用的双向链表结构，有一个头结点和一个尾结点，双向链表意味着可以从头开始正向遍历，或者是从尾开始逆向遍历，并且可以针对头部和尾部进行相应的操作。
LinkedList的特性：
①是通过链表实现的；
②查询效率不高，但是插入和删除操作性能好。如果在频繁的插入，或者删除数据时，就用linkedList性能会更好。
③linkedList是一个双向链表，并且实现了List和Deque接口中所有的列表操作，并且能存储任何元素，包括null。也就是说linkedList除了可以当链表使用，还可以当作队列使用，并能进行相应的操作。
④linkedList在执行任何操作的时候，都必须先遍历列表，通过index查找我们所需要的的值。通俗点讲，就是顺序存取，每次操作必须先按开始到结束的顺序遍历。
⑤linkedList是一个非线程安全的(异步)，其中在操作Interator时，如果改变列表结构(add\delete等)，会发生fail-fast。
3.源码分析
(1)类的属性
// 实际元素个数
transient int size = 0;
// 头结点
transient Node
// 尾结点
transient Node
LinkedList的属性有3个：一个头结点、一个尾结点、一个表示链表中实际元素个数的变量。
注意，头结点、尾结点都有transient关键字修饰，这也意味着在序列化时该域是不会序列化的。
(2)构造方法
LinkedList有两个构造方法。
①空参构造函数
public LinkedList() {
}
②有参构造函数
//将集合c中的各个元素构建成LinkedList链表
public LinkedList(Collection c) {
this(); // 调用无参构造函数
addAll(c); // 添加集合中所有的元素
}
有参构造函数会调用无参构造函数，并且会把集合中所有的元素添加到LinkedList中。
(3)内部类（Node）
private static class Node
E item; // 数据域（当前节点的值）
Node
Node
// 构造函数，赋值前驱后继
Node(Node
this.item = element;
this.next = next;
this.prev = prev;
}
}
内部类Node就是实际的结点，用于存放实际元素的地方。
(4)添加方法
①add(E)方法
//新增元素到尾部
public boolean add(E e) {
linkLast(e);//将元素添加到末尾
return true;
}
void linkLast(E e) {
final Node
final Node
last = newNode; //newNode成为了最后一个节点，所以last指向了它
if (l == null) //判断是不是一开始链表中就什么都没有，如果没有，则newNode就成为了第一个节点，first和last都要指向它
first = newNode;
else //正常的在最后一个节点后追加，那么原先的最后一个节点的next就要指向现在真正的最后一个节点，原先的最后一个节点就变成了倒数第二个节点
l.next = newNode;
size++;//添加一个节点，size自增
modCount++;
}
②addAll方法
addAll有两个重载函数。
1)、addAll(Collection c)方法
public boolean addAll(Collection c){
return addAll(size, c);
}
2)、addAll(int index, Collection c)方法
public boolean addAll(int index, Collection c) {
checkPositionIndex(index); //检查index是否为合理，其实就是检查角标是否小于0或者是否越界
Object[] a = c.toArray(); //将集合c转换为Object数组 a
int numNew = a.length; //获取数组a的长度
if (numNew == 0)
return false;
Node
if (index == size) {
succ = null;
pred = last;//在结尾追加元素
} else {
//如果在链表中间插入元素，那么就得知道index上的节点是谁，保存到succ临时节点中，然后将succ的前一个节点保存到pred中，这样保存了这两个节点，就能够准确的插入节点了
succ = node(index);
pred = succ.prev;
}
for (Object o : a) { //遍历数组a中的元素，封装为一个个节点
@SuppressWarnings("unchecked") E e = (E) o;
Node
if (pred == null)
first = newNode; //如果pred为空,说明是一个空链表,此时的newNode就当作第一个节点，所以把newNode给first头节点
else
pred.next = newNode; //如果pred！=null，说明需要将newNode挂载pred的next上
pred = newNode;//构建
}
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
参数中的index表示在索引下标为index的结点的前面插入。在addAll函数中，会调用到node函数，get函数也会调用到node函数，此函数是根据索引下标找到该结点并返回，具体代码如下：
Node
// 判断插入的位置在链表前半段或者是后半段
if (index < (size >> 1)) { // 插入位置在前半段
Node
for (int i = 0; i < index; i++) // 从头结点开始正向遍历
x = x.next;
return x; // 返回该结点
} else { // 插入位置在后半段
Node
for (int i = size - 1; i > index; i--) // 从尾结点开始反向遍历
x = x.prev;
return x; // 返回该结点
}
}
addAll()中的一个问题：
在addAll函数中，传入一个集合参数和插入位置，然后将集合转化为数组，然后再遍历数组，挨个添加数组的元素，但是问题来了，为什么要先转化为数组再进行遍历，而不是直接遍历集合呢？从效果上两者是完全等价的，都可以达到遍历的效果。关于为什么要转化为数组的问题，思考如下：
①如果直接遍历集合的话，那么在遍历过程中需要插入元素，在堆上分配内存空间，修改指针域，这个过程中就会一直占用着这个集合，考虑正确同步的话，其他线程只能一直等待。
②如果转化为数组，只需要遍历集合，而遍历集合过程中不需要额外的操作，所以占用的时间相对是较短的，这样就利于其他线程尽快的使用这个集合。说白了，就是有利于提高多线程访问该集合的效率，尽可能短时间的阻塞。
(5)删除方法
public boolean remove(Object o) {
if (o == null) {
for (Node
if (x.item == null) {
unlink(x);//使用unlink移除该值
return true;
}
}
} else {
for (Node
if (o.equals(x.item)) {
unlink(x);//使用unlink移除该值
return true;
}
}
}
return false;
}
其中用到了unlink方法：
E unlink(Node
//拿到节点x的三个属性
final E element = x.item;
final Node
final Node
//这里开始往下就进行移除该元素之后的操作，也就是把指向哪个节点搞定。
if (prev == null) {
first = next;//说明移除的节点是头节点，则first头节点应该指向下一个节点
} else {
prev.next = next; //移除的不是头节点，则prev.next=next：有1、2、3，将1.next指向3
x.prev = null;//然后解除x节点的前指向。
}
if (next == null) {
last = prev;//说明移除的节点是尾节点
} else {
//不是尾节点，有1、2、3，将3.prev指向1. 然后将2.next=解除指向。
next.prev = prev;
x.next = null;
}
//x的前后指向都为null了，也把item为null，让gc回收它
x.item = null;
size--; //移除一个节点，size自减
modCount++;
return element;
}
(6)查询方法
①get(index)方法：
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
Node
if (index < (size >> 1)) { //查询前半部分
Node
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else { //查询后半部分
Node
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
②indexOf(Object o)方法
通过实体元素来查找到该元素在链表中的位置。跟remove中的代码类似，只是返回类型不一样。
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node
if (x.item == null)
return index;
index++;
}
} else {
for (Node
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
4.总结
①linkedList本质上是一个双向链表，通过一个Node内部类实现的这种链表结构。
②能存储null值
③跟arrayList相比较，LinkedList在删除和增加等操作上性能好，而ArrayList在查询的性能上好
④从源码中看，它不存在容量不足的情况
⑤linkedList不光能够向前迭代，还能像后迭代，并且在迭代的过程中，可以修改值、添加值、还能移除值。
⑥linkedList不光能当链表，还能当队列使用，这个就是因为实现了Deque接口。