版权声明：本文为博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/qq_42191317/article/details/96752697

LinkedList类图

LinkedList是java.util包下的Collection接口下的一个子类，也是我们常用的容器，底层是一个双向链表，也可以当做双端无界队列使用，而我们知道，双端队列其实也相当于一个栈，因此LinkedList其实是一个具有多种功能的容器。

• AbstractSequentialList抽象类：AbstractList的子类，实现一些集合的通用的方法（添加、获得等，通过迭代器实现，隐藏了对下标的操作）。
• Cloneable接口：实现对象拷贝必须要实现的接口。
• Serializable接口：实现序列化必须要实现的接口。
• Deque接口：Queue接口下的一个子接口，扩展了队列相关的操作。

LinkedList属性

以上便是LinkedList的属性，下面一一介绍：

size

[code]    transient int size = 0;

链表里元素的个数。

first

[code]    transient Node<E> first;

链表的头结点。

last

[code]    transient Node<E> last;

链表的尾节点。

注意：以上三个属性都是被transient关键字修饰，表示不可被序列化。LinkedList的序列化是通过反射调用重写的readObject方法和writeObject方法实现的，之所以如此做是为了只序列化存储的数据。（具体可以参考别的博客）

serialVersionUID

[code]    private static final long serialVersionUID = 876323262645176354L;

序列化ID

Node

[code]    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的一个static内部类，链表里的每个节点都是通过Node来存储的，包含item，next，prev三个属性，item用来存储值，next用来存储后指针，prev用来存储前指针。

LinkedList常用API

[code]    public LinkedList() {
}

public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}

构造方法：

• 空参的构造方法什么都没有做，只是实例化first和last两个Node节点
• 带Collection参数的构造方法首先调用空参构造方法，然后调用addAll方法来将Collection集合添加进链表中。

[code]    public boolean add(E e) {
linkLast(e);
return true;
}

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++;
}

add方法：向链表中插入一个元素

add方法会调用linkLast方法，该方法是在链表的最后插入一个元素。

• 首先将尾节点保存起来（l）
• 然后创建值为e的新节点，将之前的尾节点设置为它的前指针
• 将新节点作为现在尾节点
• 判断之前的尾节点是否为null，即是否是第一次添加节点，如果是，则链表的首节点也是新节点，如果不是，将之前的尾节点的后指针指向现在的尾节点

[code]    public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}

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;
}

remove方法：移除指定元素。

• 首先遍历链表，如果没有找到该元素，直接返回false
• 如果找到该元素，则调用unlink方法将该元素移除 先将该元素的前后指针保存下来
• 然后判断该元素是否是首节点，如果是首节点，则将他的下一个节点当做首节点，如果不是，则将上一个节点的后指针指向它的下一个节点，将他的前指针置为null
• 然后判断该元素是否是尾节点，如果是尾节点，则将他的前一个节点当做尾节点，如果不是，则将下一个节点的前指针指向他的上一个节点，将他的后指针置为null
• 将他的值置为null（方便GC回收），size--，modcount++，modcount指的是修改的次数，与迭代器遍历有关

[code]    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方法：将一个Collection集合的元素添加到链表里。

第一个addAll方法会调用带下标的addAll方法，表示将元素要插入的位置，因此addAll默认是将元素全部插入链表尾。

• 首先调用checkPositionIndex方法来检查下标是否合理（>=0且<=size），如果不合理，抛出异常
• 然后将collection集合转化为数组，判断数组里元素个数，如果为0则直接返回false
• 然后初始化两个Node，这两个节点可以用来判断要插入的位置
• 遍历数组，将元素全部插入
• 根据之前初始化的两个Node来判断是插入链表尾还是插入其余位置，然后更新相应的头结点或者尾节点
• 更新size个数，modcount++

[code]       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);
}

addFirst方法：在链表头部加入一个节点

addLast方法：在链表尾部加入一个节点

removeFirst方法：删除链表头部第一个元素

removeLast方法：删除链表尾部第一个元素

linkLast和linkFirst方法之前介绍过，这里不再赘述。

[code]       public E get(int index) {
checkElementIndex(index);
return node(index).item;
}

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;
}
}

get方法：获得指定下标的元素。

• 首先调用checkElementIndex方法来验证下标是否合理
• 然后调用node方法来获得指定下标的元素 首先size右移一位，即size除以2，获得元素的中间下标
• 如果index<mid，则要查找的下标离头结点更近，从头结点遍历查找
• 反之index>mid，则要查找的下标离尾节点更近，从尾节点遍历查找

[code]    public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}

set方法：修改指定下标的元素值。

• 首先调用checkElementIndex方法来验证下标是否合理
• 然后调用node方法来获得指定下标的元素
• 然后更新该元素并返回旧的元素值

[code]   public void clear() {
// Clearing all of the links between nodes is "unnecessary", but:
// - helps a generational GC if the discarded nodes inhabit
//   more than one generation
// - is sure to free memory even if there is a reachable Iterator
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++;
}

clear方法：清空链表。

• 遍历链表，所有属性置为null（方便GC回收）
• 头结点和尾节点置为null，size归零，modcount++

[code]    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;
}

contains方法：判断列表中是否存在某个元素。

调用indexOf方法来查找该元素，如果不存在，返回下标为-1

indexOf方法：从头结点开始遍历，如果找到，返回对应下标，如果没找到，返回-1

[code]    public int size() {
return size;
}

size方法：返回当前链表中的元素个数。

 

================================================================================================

=======================  以上方法均是操作链表的方法  以下方法用来操作队列  ===============================

================================================================================================

 

[code]    public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}

poll方法：弹出队列元素，从链表头部取出，如果是空链表则返回null，会将链表头结点删除

[code]    public E pop() {
return removeFirst();
}

public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}

pop方法：弹出队列元素，从链表头部取出，如果是空链表则会抛出异常，会将链表头结点删除

[code]    public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}

peek方法：查看队头元素，从链表头部取出，如果是空链表则会返回null，不会将链表头结点删除

[code]    public void push(E e) {
addFirst(e);
}

push方法：向队列中添加一个元素，从链表的头部插入

总结

• LinkedList底层是一个双向链表。
• LinkedList还实现了Queue的子接口Deque，实现了一些队列的方法，因此他还是一个双端无界队列，而双端无界队列也可以用来当做栈使用。
• LinkedList在队列首尾添加元素非常高效，时间复杂度为O(1)，在中间添加删除的时间复杂度为O(n)。
• LinkedList为了性能考虑，一方面在删除元素或者清空链表时，不只是将链表切断，而且会将切除的Node节点全部置为null，方便GC回收，另一方面，他实现了序列化接口，但又将存储数据的前指针、后指针、元素个数等属性设置为transient，禁止自动序列化，而是通过实现readObject和writeObject方法来只序列化实际存储的数据，减少空间的占用。