前言
LinkedList类是List接口的一种实现,它表示一个列表。同时,LinkedList类也是Deque接口的一种实现,所以它也可以表示一个双端队列。Deque接口除了提供操作双端队列的一系列方法之外,还提供了操作栈的方法,因此LinkedList还可以表示一个栈。ArrayList类也是List接口的一种实现,它是基于数组实现的。LinkedList是基于双向链表实现的。LinkedList与ArrayList一样,都是非线程安全的。
相关知识
源码分析
定义
public class LinkedList<E> extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
...
}
LinkedList类继承于AbstractSequentialList类。AbstractSequentialList类提供了List接口的一个框架实现,以最小化实现这个支持“顺序访问”数据存储(例如链表)的接口所需的工作量。
LinkedList类实现了4个接口:
- List 列表接口,提供了操作列表的一系列方法,例如:add()、remove()、set()、get()等方法。
- Deque 双端队列接口,提供了操作双端队列和栈的一系列方法,例如:offerFirst()、offerLast()、pollFirst()、pollLast()、peekFirst()、peekLast()、push()、pop()等方法。
- Cloneable 可克隆标记接口,表示对象可以被克隆。
- Serializable 序列化标记接口,表示对象可以被序列化。
对于Deque接口,实际上它提供了两套操作双端队列的方法:
offer系列 | add系列 | 方法描述 |
---|---|---|
offerFirst() | addFirst() | 将指定的元素插入到队首。 |
offerLast() | addLast() | 将指定的元素添加到队尾。 |
pollFirst() | removeFirst() | 取出并删除队首的元素。 |
pollLast() | removeLast() | 取出并删除队尾的元素。 |
peekFirst() | getFirst() | 取出队首的元素,但不删除。 |
peekLast() | getLast() | 取出队尾的元素,但不删除。 |
它们的区别是:offer系列方法在操作失败时会返回一个特殊值(根据操作的不同,为false或者null);add系列方法在操作失败时会抛出异常。
主要变量
transient Node<E> first;
transient Node<E> last;
transient int size = 0;
其中:
- first 链表的第一个节点。
- last 链表的最后一个节点。
- size 列表中包含的元素的个数。
列表的元素是存储在链表节点中的,链表节点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;
}
}
其中:
- item 列表的元素。
- next 下一个节点。
- prev 上一个节点。
因此,LinkedList是基于 双向链表 实现的。
构造方法
public LinkedList() {
}
默认构造方法构造了一个空列表。
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
该构造方法构造了一个包含了指定集合元素的列表。
add()方法
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()方法。linkLast()方法新建了一个节点来存储元素,并将该节点链接到链表的末尾。最后更新了size变量。可以看出add()方法是支持null元素和重复元素的。
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
Node<E> node(int 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;
}
}
void linkBefore(E e, Node<E> succ) {
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++;
}
该add()方法将指定的元素添加到列表中指定的位置。首先调用checkPositionIndex()方法检查指定的位置索引的合法性。然后判断是将元素添加到列表的末尾还是插入到列表的其它位置。如果是将元素添加到列表的末尾,那么调用linkLast()方法将元素添加到列表的末尾。如果是将元素插入到列表的其它位置,那么先调用node()方法取出指定的位置索引处的节点,然后调用linkBefore()方法将指定的元素插入到指定的位置索引处的节点的前面。node()方法使用了一次二分查找,返回了指定的位置索引处的节点。linkBefore()方法新建了一个节点来存储元素,并将该节点链接到指定节点的前面。
remove()方法
public E remove(int index) {
checkElementIndex(index);
return unlink(node(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) {
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()方法删除列表中指定位置的元素。首先调用checkElementIndex()方法检查指定的位置索引的合法性。然后调用node()方法取出指定的位置索引处的节点。最后调用unlink()方法删除指定的位置索引处的节点。
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;
}
该remove()方法删除列表中第一个与指定元素相等的元素。如果列表中不包含与指定元素相等的元素,那么列表保持不变。remove()方法循环遍历链表,查找第一个存储元素与指定元素相等的节点。如果找到,那么调用unlink()方法删除存储该元素的节点。
set()方法
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()方法取出指定的位置索引处的节点。接着将指定的位置索引处的节点中的元素替换为指定的新元素。最后返回旧元素。
get()方法
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
get()方法返回列表中指定位置的元素。首先调用checkElementIndex()方法检查指定的位置索引的合法性。然后调用node()方法取出指定的位置索引处的节点。最后返回指定的位置索引处的节点中的元素。
其它方法
理解了LinkedList的add()、remove()、set()、get()方法之后,其它方法就很好理解了。
总结
- LinkedList可以作为一个列表,也可以作为一个双端队列,还可以作为一个栈。
- LinkedList是基于双向链表实现的。
- LinkedList在查找元素时,需要遍历链表(有一次二分查找优化),因此查找元素效率低。
- LinkedList在列表中间插入或者删除元素时,不需要移动元素,因此插入或者删除元素效率高。
- LinkedList按照添加元素的顺序存储元素。
- LinkedList允许元素为null。
- LinkedList允许元素重复。
- LinkedList是非线程安全的。
参考
- https://docs.oracle.com/javase/8/docs/api/java/util/LinkedList.html