前言:继上篇，ArrayList和LinkedList算是一对兄弟，虽然它们都实现了List接口，但是它们的本质却相差很大。
目录:
一. 概述
二. 源码分析
(1) LinkedList初始化
(2) LinkedList增加元素操作【增】
(3) LinkedList的删除元素操作【删】
(4) LinkedList的替换元素操作【改】
(5) LinkedList的获取元素操作【查】
三. 与ArrayList的区别
(1)相同点
(2)不同点
四. 总结
一. 概述
（1）LinkedList是基于双向链表实现的，链表具有插入和删除效率高而改查效率低的特点。
（2）因为使用链表的原因，所以不存在容量不足的问题，没有扩容机制。
（3）LinkedList继承了AbstractSequentialList，而AbstractSequentialList为顺序访问的数据存储结构提供了一个骨架类实现。实现了Deque<E>接口, Deque是Queue的子接口,Queue是一种队列形式,而Deque是双向队列,它支持从两个端点方向检索和插入元素。
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
二. 源码分析
(1) LinkedList初始化
构造方法
//元素个数
transient int size = 0;
//链表头节点
transient Node<E> first;
//链表尾节点
transient Node<E> last;
//无参构造器
public LinkedList() {
}
//有参构造器，参数为LinkedList集合，把集合c里的元素插入到链表中
public LinkedList(Collection<? extends E> c) {
this();
//插入集合方法后面分析
addAll(c);
}节点Node
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;
}
}
从上面可以看出，LinkedList底层是基于Node实现的，是一个双向链表
(2) LinkedList增加元素操作【增】
1.添加单个元素到l链表末尾，add(E e)方法
public boolean add(E e) {
linkLast(e);
return true;
}
//直接调用添加末尾的方法
void linkLast(E e) {
//尾节点
final Node<E> l = last;
//构建新的节点,之前的尾节点为前一个节点，null为后一个节点
final Node<E> newNode = new Node<>(l, e, null);
//设置新的节点为尾节点
last = newNode;
//如果l为null(即原来链表为空链表),需要额外说明新的节点为首节点,否则就设置新的节点为l的下一节点
if (l == null)
first = newNode;
else
l.next = newNode;
size++;//链表的大小+1
modCount++;
}2.添加单个元素到指定位置，add(int index, E element)方法
public void add(int index, E element) {
//校验index有效性[0,size]
checkPositionIndex(index);
//如果index等于size,说明添加到链表末尾，直接调用添加末尾的方法
if (index == size)
linkLast(element);
else
//否则调用添加到 index位置的前一个节点
linkBefore(element, node(index));
}
void linkBefore(E e, Node<E> succ) {
//记下前一个节点为当前节点的上一个节点
final Node<E> pred = succ.prev;
//构建新的节点，新的节点前一个节点为pred，后一节点为原index位置的节点
final Node<E> newNode = new Node<>(pred, e, succ);
//同步更新原index位置的节点为前节点为新的节点
succ.prev = newNode;
//同时判断pred是否为空，为空的话说明首节点就是新的节点，否则同步更新pred.next为新的节点
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
//这个方法的思路是 判断index在链表的前半部分还是后半部分,如果是前半部分就从首节点遍历，否则就从尾节点遍历获取节点
Node<E> node(int index) {
if (index < (size >> 1)) {
//记下首节点，从首节点往后遍历找到index位置的节点
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
//记下尾节点，从尾节点往前遍历找到index位置的节点
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}这里要总结一下，作为链表的插入、后续要讲的删除操作，直观上是破坏了原有的结构，无论是插入在首位置、中间位置、还是末位置都要重新连接起来。即新的节点要主动关联前后节点，前后节点也要主动关联新的节点。
3.添加集合到数组末尾，addAll(Collection<? Extends E> c)方法
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
//校验index有效性[0,size]
checkPositionIndex(index);
//将集合转化为数组
Object[] a = c.toArray();
int numNew = a.length;
//如果是空数组，返回false
if (numNew == 0)
return false;
//定义index位置的前置节点、后置节点
Node<E> pred, succ;
if (index == size) {
//如果index为链表的长度，则说明批量添加到链表的末尾,前置节点为最后一个元素,后置节点为null
succ = null;
pred = last;
} else {
//后置节点为修改前index位置的元素，前置节点为修改前index位置的元素的前一个节点
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) {
//判断succ是否为空，为空的话集合的最后一个元素就是尾节点
last = pred;
} else {
//否则succ链接到集合的最后一个元素
pred.next = succ;
succ.prev = pred;
}
//链表长度增加集合的长度
size += numNew;
modCount++;
return true;
}4.添加集合到指定位置，addAll(int index，Collection<? Extends E> c)方法
上面已对该方法分析。
(3) LinkedList的删除元素操作【删】
1.移除指定位置的元素，remove(int index)方法
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
//单从方法名字可以看出，意为失连。即index位置的元素与前后节点失去连接。同时前后节点又关联起来
E unlink(Node<E> x) {
//定义当前元素
final E element = x.item;
//定义当前元素的后置结点
final Node<E> next = x.next;
//定义当前元素的前置结点
final Node<E> prev = x.prev;
if (prev == null) {
//如果前置结点为null,则说明删除的就是第一个结点，头结点就是next
first = next;
} else {
//否则，前置结点的后结点就是next
prev.next = next;
//删除的节点的前置结点置空
x.prev = null;
}
if (next == null) {
//如果后置结点为null，则说明删除的就是最后一个节点,尾节点就是prev
last = prev;
} else {
//否则，后置结点的前结点就是prev
next.prev = prev;
//删除的节点的后置结点置空
x.next = null;
}
//删除的元素置空
x.item = null;
//链表的长度-1
size--;
modCount++;
return element;
}2.移除指定的元素，remove(Object o)方法
public boolean remove(Object o) {
if (o == null) {
//遍历链表，调用unlink(x)
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
//遍历链表,调用unlink(x)
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
3.清空集合，clear()方法
public void clear() {
//遍历链表，将元素的前后节点、自身都设为null
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
} (4) LinkedList的替换元素操作【改】
1.替换指定位置的元素，set(int index， E element)方法
public E set(int index, E element) {
//检查索引有效性
checkElementIndex(index);
//获取index位置的元素
Node<E> x = node(index);
//记下当前节点的元素
E oldVal = x.item;
//将新值覆盖旧值
x.item = element;
//返回旧的值
return oldVal;
} (5) LinkedList的获取元素操作【查】
获取元素操作大致归纳为获取元素，判断集合是否包含某个元素。
1.获取指定位置的元素，get(int index)方法
public E get(int index) {
//检查索引有效性
checkElementIndex(index);
//调用node(index)方法，前面已分析过
return node(index).item;
}2.判断集合是否含有某个元素，contains(Object o)方法
public boolean contains(Object o) {
return indexOf(o) != -1;
}
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;
}三. 与ArrayList的区别
(1) 相同点
1.两个都是线程不安全的
2.两个都允许元素为null
3.两个都是实现了List接口
(2) 不同点
1.LinkedList是基于双向链表实现的，继承了AbstractSequentialList，便于顺序访问。
ArrayList是基于动态数组实现的，继承了AbstractList，支持随机访问。
2.Linked没有扩容机制。
3.LinkedList在add()、remove()操作有这很好的性能，而ArrayList在get()有较好的性能
四. 总结
(1).在遍历LinkedList，尽量别用for循环遍历，特别是在数据量很大的时候。可以用foreach，或者iterator来遍历。
254
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
