先对LinkedList的特性进行一个概述：
（1）LinkedList底层实现为双向循环链表。链表的特点就是插入删除数据快，而查询数据慢。
（2）因为使用链表的原因，所以不存在容量不足的问题，没有扩容机制。
（3）从后面的源码分析中我们也可以看出，LinkedList支持null并且LinkedList没有同步机制。
（4）LinkedList直接继承于AbstractSequentialList，同时实现了List接口，也实现了Deque接口。
AbstractSequentialList为顺序访问的数据存储结构提供了一个骨架类实现，如果要支持随机访问，则优先选择AbstractList类继承。LinkedList 基于链表实现，因此它继承了AbstractSequentialList。本文原创，转载请注明出处：[http://blog.csdn.net/seu_calvin/article/details/53012654]
LinkedList的数据存储格式：
private static class Node<E>{
E item;
Node<E> prev;
Node<E> next;
public Node(Node<E> prev,E item,Node<E> next){
this.prev = prev;
this.item = item;
this.next = next;
}
}
LinkedList中定义了三个临时的变量
transient int size = 0;//链表大小
transient Node<E> first;//头节点
transient Node<E> last; //尾节点
LinkedList的构造方法有两种，如下：
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
可以看到在有参的构造方法中，首先先调用了无参的构造方法，然后调用addAll()方法，下边讲解下这个方法，首先判断第一个参数index的大小，如果大于size或者小于0则抛出越界异常，然后设置了两个Node类型的量，pred表示插入集合C的头节点的前一个节点，succ表示插入集合C的尾节点的后一个节点，如果index==size,说明插入的位置是在链表的尾部，那么头结点就是原来的last,尾节点就是Null;否则，则是中间插入的方式，那么首先将该节点的头尾节点分别赋值给pred和succ，然后使用一个for循环输出集合C中的数据，每个都使用Node进行包装，这部分只要注意pred在里边类似于指针的作用，每次循环，pred 都将指向下一个节点；这样循环到最后，还要对插入位置进行判断，如果succ为Null,则是在链表尾插入，则直接设置last=pred,否则将pred.next=succ;succ.prev = pred;对插入节点尾部进行一个头尾的指针指向。
LinkedList的一些内部方法，仅供内部方法调用
private void linkFirst(E e)//插入头结点
void linkLast(E e)//插入尾节点
void linkBefore(E e, Node<E> succ)//在某个节点前插入
private E unlinkFirst(Node<E> f)//删除头结点
private E unlinkLast(Node<E> l)//删除尾节点
E unlink(Node<E> x)//删除某个节点
//插入头结点
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++;
}
//插入尾节点
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++;
}
//在某个节点前插入
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++;
}
//删除头结点
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;
}
//删除尾节点
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;
}
//删除某个节点
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;
}
注意一个点，添加和删除节点，都会对first和last进行相关的处理工作，并且这些方法中创建的节点都是final的。
LinkedList常用的一些方法：
public E getFirst()
public E getLast()
public E removeFirst()
public E removeLast()
public void addFirst(E e)
public void addLast(E e)
这六个方法是LinkedList中对于首尾节点的操作方法，直接调用上面的内部方法就能够解决了。
下面介绍几个其他的方法：
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
node()方法是根据传入的索引，返回具体的节点，这个方法有意思，他不是死脑筋的从头遍历到尾，他首先将index和size的中间值进行了判断，如果index<size的中间值，则只需遍历左半边的，如果index>size的中间值，则遍历右半边。这样在遍历右半边的时候，将大大的提高程序的执行效率。
public int indexOf(Object o)和方法 public int lastIndexOf(Object o)类似，前一个是从头找到跟o数据匹配的节点索引，后一个是从尾找到跟o数据匹配的节点索引，这边就将第一个方法吧，代码如下：
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
看到这段代码有没有点熟悉感，没错，先进行了o是否是空值的判断，空值用==进行比较，非空值用equals进行比较，最后返回Index的值大小。
对List的其他相关方法总结一下：
public boolean contains(Object o)//集合中是否包含o数据
public boolean add(E e)//从尾节点新增一个节点，数据为e
public boolean remove(Object o)//从头开始，删除一个集合中数据为o的节点
public void clear()//清空集合所有的节点
public E get(int index)//获取索引位置为Index的数据信息
public E set(int index, E element)//设置Index位置的节点数据为element
public void add(int index, E element)//在index位置新增一个节点数据为element
public E remove(int index)//删除Index位置的节点
public boolean removeFirstOccurrence(Object o)//里边调用的是remove(Object o)的方法，跟这个方法作用相同
public boolean removeLastOccurrence(Object o)//从尾开始，删除一个集合中数据为o的节点。
关于list的方法方面讲完了，下面介绍LinkedList实现deque和stack的方法：
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E element() {
return getFirst();
}
peek()方法和element()方法都是 获取但不移除第一个元素，区别在于，如果第一个元素为空，peek返回Null,而element抛出异常
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E remove() {
return removeFirst();
}
poll()方法和remove()方法都是获取并且会移除第一个元素，区别在于，如果第一个元素为空，poll()返回Null,而remove抛出异常。
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
前两个方法获取头尾节点的值但不移除头尾节点，如果为空则返回null,
后两个方法获取头尾节点的值，并且会移除头尾节点，如果为空则返回null
public void push(E e) {
addFirst(e);
}
public E pop() {
return removeFirst();
}
这两个方法是属于stack方面的，入栈和出栈，符合先进先出的规则，如果遇到空元素则抛出异常
这两天研究了ArrayList和LinkedList的源码，下面对这两个集合类进行对比
共同点：
1、都是线程不安全的集合
2、都支持null值
3、都实现了List接口
不同点：
1、ArrayList的底层是用数组实现的，每次增加数据都要考虑扩容的情况，LinkedList底层是通过链表实现的，不需要考虑扩容的情况
2、LinkedList 基于链表实现，便于顺序访问，它继承了AbstractSequentialList。而ArrayList支持随机访问，继承了AbstractList类
3、通过源码我们知道，如果要对数据进行查询，那么ArrayList比较合适，因为ArrayList是通过数组实现的，那么只需要获取索引就可以获取该值，但是LinkedList需要从头或尾遍历到值才行；如果要对数据进行增删操作，则LinkedList比较合适，通过代码我们知道，ArrayList需要通过System.arraycopy移动数组来实现，而LinkedList只需要修改前后的指针指向就可以完成增删操作，所以在增删操作上，LinkedList比较合适，当然如果是在头部或者尾部，二者的效率没有多大的区别
参考链接：
https://blog.csdn.net/wangbiao007/article/details/52539061
https://blog.csdn.net/seu_calvin/article/details/53012654
网友评论