Java-Collections Framework学习与总结-LinkedList

最新推荐文章于 2025-12-08 10:04:31 发布

转载最新推荐文章于 2025-12-08 10:04:31 发布 · 411 阅读

Java基础知识专栏收录该内容

18 篇文章

订阅专栏

本文深入剖析了Java中LinkedList集合的实现细节，包括其接口实现、数据结构设计以及操作时间复杂度分析。重点探讨了如何通过双向链表结构在集合首尾进行插入和删除操作的高效性，并揭示了基于位置访问元素的低效性。通过实例代码和优化策略，展示了如何在实际场景中灵活运用LinkedList来提升数据处理效率。

ArrayList的插入和删除元素的操作会花费线性时间，那么有没有插入和删除元素比较省时的集合呢，看下LinkedList这个实现。
老样子，先看看它实现了那些接口。

Java代码

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable

之前看过的接口不看了。先看下java.util.Deque。

Java代码

public interface Deque<E> extends Queue<E>

这个接口扩展了java.util.Queue，Queue也是Java Collections Framework中一个重要的接口，它表示了队列。当然队列本身也属于集合(java.util.Collection是更高层次的抽象)。

Java代码

public interface Queue<E> extends Collection<E>{
boolean add(E e);
boolean offer(E e);
E remove();
E poll();
E element();
E peek();
}

Queue提供了添加、删除和获取元素的方法，每种方法提供2个版本。如添加元素，add和offer都可以完成这个操作，区别在于add方法如果添加失败会抛出异常，而offer方法则会返回false。Queue接口只提供队列的抽象概念，但并没有定义元素的操作顺序。其实现可以提供先入先出或者先入后出(栈)这样的性质。

大概了解了java.util.Queue后继续看java.util.Deque。既然Deque扩展了Queue，那它本质上也是队列喽。原来Deque是“double ended queue”的缩写，也就是双端队列的意思，单词读音为“deck”(蛋壳儿。。。)。 so，这个接口定义了在队列两端操作(添加、删除和获取)元素的方法。

Java代码

public interface Deque<E> extends Queue<E> {
void addFirst(E e);
void addLast(E e);
boolean offerFirst(E e);
boolean offerLast(E e);
E removeFirst();
E removeLast();
E pollFirst();
E pollLast();
E getFirst();
E getLast();
E peekFirst();
E peekLast();
boolean removeFirstOccurrence(Object o);
boolean removeLastOccurrence(Object o);
void push(E e);
E pop();
Iterator<E> descendingIterator();
}

        像Queue接口一样，Deque也对这些操作方法提供了2个版本。

        接下来看一下java.util.AbstractSequentialList这个抽象类，这个类的作用和java.util.AbstractList作用一样，提供一些“骨架”实现。区别在于这个类提供了“按次序访问”的基础，而AbstractList提供了“自由访问”的基础。也就是说，如果我们要实现一个基于链表的集合的话，可以继承这个类；要实现基于数组的集合的话，就继承AbstractList类。

        好了，在看LinkedList的源代码之前，还是先思考一下，如果自己实现LinkedList要怎么做。既然是链表，那么内部一定会有一个“链”，而“链”是由“环”组成，说明内部会有“环”这样的概念。每个环都和下一个环相扣，有两个特殊的环，首环和尾环。首先，没有任意一环的下一环是首环，尾环没有下一环；然后，首环和尾环上是不携带数据的(当然普通环也是可以保存null元素滴)。如果再从代码上考虑一下，每一个环都有下一个环的引用，这样可以构成一个链。但每个环也可以即有上一个环的引用，又有下一个环的引用，也可以构成链。它们有什么区别呢？其实这就是所谓的单向链表和双向链表，java.util.LinkedList内部使用双向链表实现。那可以使用单向链表实现吗？那就试试吧。
        首先要有头节点和尾节点，设想一下，如果没有它们，我们要保存的数据该放哪。。。然后还是要有一个size的私有变量，这样一些方法就好实现了。

Java代码

/**
* 单向链表实现的LinkedList
* 每个节点含有本节点元素及指向下一个节点的链，
* 最后一个节点的next链为空。
*
* @author BrokenDreams
*/
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>,Deque<E>{
//头节点
private Entry<E> header = new Entry<E>(null, null);
//尾节点
private Entry<E> tail = new Entry<E>(null, null);
private transient int size = 0;
public LinkedList() {
header.next = tail;
}
public LinkedList(Collection<? extends E> c){
this();
addAll(c);
}

“环”的实现很简单。是一个内部类。

Java代码

private static class Entry<E> {
E element;
Entry<E> next;
public Entry(E element, Entry<E> next) {
super();
this.element = element;
this.next = next;
}
}

之前在总结ArrayList的时候，看到了当在集合尾部插入元素时，操作时间为常数时间(假设没有进行数组扩展)；但当往集合首部插入元素时，内部数组中所有的元素都得往后移动一个位置(内部进行数组的拷贝)，这样会花费O(n)的时间。我们看下单向链表实现里的情况。

Java代码

@Override
public boolean add(E e) {
if(size == 0){
addAfter(e, header);
return true;
}
Entry<E> node = header.next;
while(node != null){
if(node.next == tail){
addAfter(e, node);
return true;
}
node = node.next;
}
//never here
return false;
}
private Entry<E> addAfter(E e, Entry<E> entry){
Entry<E> newEntry = new Entry<E>(e, null);
Entry<E> nextEntry = entry.next;
entry.next = newEntry;
newEntry.next = nextEntry;
size++;
modCount++;
return newEntry;
}
@Override
public void addFirst(E e) {
addAfter(e, header);
}

可以看到，当在集合首部插入元素时，操作时间为常数时间；但当在集合尾部插入元素时，由于我们访问内部数据的入口只有内部的header和tail，又因为是单向链，我们要在集合尾部插入元素时，需要改变tail前一个元素的next，而要找到tail的前一个元素，需要从header开始往下找，所以操作时间还是O(n)，看来单向链表还是不能达到我们的目的。。。

好啦，还是看看LinkedList怎么玩儿的吧。

Java代码