LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的，是线程不安全的，允许元素为null的双向链表。
/***集合元素数量**/transientintsize=0;/***指向第一个节点的指针*Invariant:(first==null&&last==null)||*(first.prev==null&&first.item!=null)*/transient Node<E>first;/***指向最后一个节点的指针*Invariant:(first==null&&last==null)||*(last.next==null&&last.item!=null)*/transient Node<E>last;
/***无参构造方法*/public LinkedList(){}/***将集合c所有元素插入链表中*/public LinkedList(Collection<? extends E>c){this();addAll(c);}
private staticclassNode<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既有prev也有next,所以证明它是一个双向链表。
将集合c添加到链表，如果不传index，则默认是添加到尾部。如果调用addAll(int index, Collection c)方法，则添加到index后面。
/***将集合添加到链尾*/public boolean addAll(Collection<? extends E>c){returnaddAll(size,c);}/****/public boolean addAll(intindex,Collection<? extends E>c){checkPositionIndex(index);//拿到目标集合数组
Object[]a=c.toArray();//新增元素的数量intnumNew=a.length;//如果新增元素数量为0，则不增加，并返回falseif(numNew==0)returnfalse;//定义index节点的前置节点，后置节点
Node<E>pred,succ;//判断是否是链表尾部，如果是：在链表尾部追加数据//尾部的后置节点一定是null，前置节点是队尾if(index==size){succ=null;pred=last;}else{//如果不在链表末端(而在中间部位)//取出index节点，并作为后继节点
succ=node(index);//index节点的前节点 作为前驱节点
pred=succ.prev;}//链表批量增加，是靠for循环遍历原数组，依次执行插入节点操作for(Object o:a){@SuppressWarnings("unchecked")//类型转换
E e=(E)o;//前置节点为pred，后置节点为null，当前节点值为e的节点newNode
Node<E>newNode=new Node<>(pred,e,null);//如果前置节点为空， 则newNode为头节点，否则为pred的next节点if(pred==null)first=newNode;elsepred.next=newNode;pred=newNode;}//循环结束后，如果后置节点是null，说明此时是在队尾追加的if(succ==null){//设置尾节点
last=pred;}else{//否则是在队中插入的节点 ，更新前置节点 后置节点
pred.next=succ;succ.prev=pred;}//修改数量size
size+=numNew;//修改modCount
modCount++;returntrue;}/***取出index节点*/Node<E>node(intindex){//assertisElementIndex(index);//如果index 小于 size/2,则从头部开始找if(index<(size>>1)){//把头节点赋值给x
Node<E>x=first;for(inti=0;i<index;i++)//x=x的下一个节点
x=x.next;returnx;}else{//如果index 大与等于 size/2，则从后面开始找
Node<E>x=last;for(inti=size-1;i>index;i--)x=x.prev;returnx;}}//检测index位置是否合法
private void checkPositionIndex(intindex){if(!isPositionIndex(index))throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}//检测index位置是否合法
private boolean isPositionIndex(intindex){returnindex>=0&&index<=size;}
假设我们要在index=2处添加{1,2}到链表中，图解如下：
第一步：拿到index=2的前驱节点 prev=ele1。
第二步：遍历集合prev.next=newNode，并实时更新prev节点以便下一次。
遍历:prev=newNode
第三步：将index=2的节点ele2接上:prev.next=ele2,ele2.prev=prev。
注意node(index)方法:寻找处于index的节点，有一个小优化，结点在前半段则从头开始遍历，在后半段则从尾开始遍历，这样就保证了只需要遍历最多一半结点就可以找到指定索引的结点。
将e元素添加到链表并设置其为头节点(first)。
public void addFirst(E e){linkFirst(e);}//将e链接成列表的第一个元素
private void linkFirst(E e){final Node<E>f=first;//前驱为空，值为e，后继为f
final Node<E>newNode=new Node<>(null,e,f);first=newNode;//若f为空，则表明列表中还没有元素，last也应该指向newNodeif(f==null)last=newNode;else//否则，前first的前驱指向newNode
f.prev=newNode;size++;modCount++;}
拿到first节点命名为f。
新创建一个节点newNode设置其next节点为f节点。
将newNode赋值给first。
若f为空，则表明列表中还没有元素，last也应该指向newNode；否则，前first的前驱指向newNode。
将e元素添加到链表并设置其为尾节点(last)。
public void addLast(E e){linkLast(e);}/***将e链接成列表的last元素*/void linkLast(E e){final Node<E>l=last;//前驱为前last，值为e，后继为null
final Node<E>newNode=new Node<>(l,e,null);last=newNode;//最后一个节点为空，说明列表中无元素if(l==null)//first同样指向此节点
first=newNode;else//否则，前last的后继指向当前节点
l.next=newNode;size++;modCount++;}
过程与linkFirst()方法类似，这里略过。
在尾部追加元素e。
public boolean add(E e){linkLast(e);returntrue;}void linkLast(E e){final Node<E>l=last;//前驱为前last，值为e，后继为null
final Node<E>newNode=new Node<>(l,e,null);last=newNode;//最后一个节点为空，说明列表中无元素if(l==null)//first同样指向此节点
first=newNode;else//否则，前last的后继指向当前节点
l.next=newNode;size++;modCount++;}
在链表的index处添加元素element.
public void add(intindex,E element){checkPositionIndex(index);if(index==size)linkLast(element);elselinkBefore(element,node(index));}/***在succ节点前增加元素e(succ不能为空)*/void linkBefore(E e,Node<E>succ){//assertsucc!=null;//拿到succ的前驱
final Node<E>pred=succ.prev;//新new节点：前驱为pred，值为e，后继为succ
final Node<E>newNode=new Node<>(pred,e,succ);//将succ的前驱指向当前节点
succ.prev=newNode;//pred为空，说明此时succ为首节点if(pred==null)//指向当前节点
first=newNode;else//否则，将succ之前的前驱的后继指向当前节点
pred.next=newNode;size++;modCount++;}
linkLast方法上文有讲。
linkBefore(E e, Node<E> succ)方法步骤：
拿到succ的前驱节点。
新new节点：前驱为pred，值为e，后继为succ : Node<>(pred, e, succ)。
将succ的前驱指向当前节点。
pred为空，说明此时succ为首节点,first指向当前节点;否则，将succ之前的前驱的后继指向当前节点。
根据索引获取链表中的元素。
public E get(intindex){checkElementIndex(index);returnnode(index).item;}//检测index合法性
private void checkElementIndex(intindex){if(!isElementIndex(index))throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}//根据index 获取元素
Node<E>node(intindex){//assertisElementIndex(index);if(index<(size>>1)){Node<E>x=first;for(inti=0;i<index;i++)x=x.next;returnx;}else{Node<E>x=last;for(inti=size-1;i>index;i--)x=x.prev;returnx;}}
node方法上文有详细讲解，这里不做介绍。
获取头节点。
public E getFirst(){final Node<E>f=first;if(f==null)throw new NoSuchElementException();returnf.item;}
获取尾节点。
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
根据Object对象删除元素。
publicbooleanremove(Objecto){// 如果o是空if(o==null){// 遍历链表查找 item==null 并执行unlink(x)方法删除for(Node<E>x=first;x!=null;x=x.next){if(x.item==null){unlink(x);returntrue;}}}else{for(Node<E>x=first;x!=null;x=x.next){if(o.equals(x.item)){unlink(x);returntrue;}}}returnfalse;}Eunlink(Node<E>x){// assert x != null;// 保存x的元素值finalEelement=x.item;//保存x的后继finalNode<E>next=x.next;//保存x的前驱finalNode<E>prev=x.prev;//如果前驱为null，说明x为首节点，first指向x的后继if(prev==null){first=next;}else{//x的前驱的后继指向x的后继，即略过了xprev.next=next;// x.prev已无用处，置空引用x.prev=null;}// 后继为null，说明x为尾节点if(next==null){// last指向x的前驱last=prev;}else{// x的后继的前驱指向x的前驱，即略过了xnext.prev=prev;// x.next已无用处，置空引用x.next=null;}// 引用置空x.item=null;size--;modCount++;// 返回所删除的节点的元素值returnelement;}
遍历链表查找 item==null 并执行unlink(x)方法删除。
如果前驱为null，说明x为首节点，first指向x的后继,x的前驱的后继指向x的后继，即略过了x。
如果后继为null，说明x为尾节点，last指向x的前驱；否则x的后继的前驱指向x的前驱，即略过了x，置空x.next。
引用置空：x.item = null。
图解。
根据链表的索引删除元素。
publicEremove(intindex){checkElementIndex(index);//node(index)会返回index对应的元素returnunlink(node(index));}Eunlink(Node<E>x)方法上文有详解。
删除头节点。
publicEremoveFirst(){finalNode<E>f=first;if(f==null)thrownewNoSuchElementException();returnunlinkFirst(f);}privateEunlinkFirst(Node<E>f){// assert f == first && f != null;//取出首节点中的元素finalEelement=f.item;//取出首节点中的后继finalNode<E>next=f.next;f.item=null;f.next=null;// help GC// first指向前first的后继，也就是列表中的2号位first=next;//如果此时2号位为空，那么列表中此时已无节点if(next==null)//last指向nulllast=null;else// 首节点无前驱next.prev=null;size--;modCount++;returnelement;}
原理与添加头节点类似。
删除尾节点(last)
publicEremoveLast(){finalNode<E>l=last;if(l==null)thrownewNoSuchElementException();returnunlinkLast(l);}privateEunlinkLast(Node<E>l){// assert l == last && l != null;// 取出尾节点中的元素finalEelement=l.item;// 取出尾节点中的后继finalNode<E>prev=l.prev;l.item=null;l.prev=null;// help GC// last指向前last的前驱，也就是列表中的倒数2号位last=prev;// 如果此时倒数2号位为空，那么列表中已无节点if(prev==null)// first指向nullfirst=null;else// 尾节点无后继prev.next=null;size--;modCount++;// 返回尾节点保存的元素值returnelement;}
修改元素比较简单，先找到index对应节点，然后对值进行修改。
publicEset(intindex,Eelement){checkElementIndex(index);// 获取到需要修改元素的节点Node<E>x=node(index);// 保存之前的值EoldVal=x.item;// 执行修改x.item=element;// 返回旧值returnoldVal;}
优点：
不需要扩容和预留空间,空间效率高。
增删效率高。
缺点：
随机访问时间效率低。
改查效率低。