JAVA集合_LinkedList详解

用户1862376301058
264 阅读4分钟

JAVA集合_LinkedList详解

一、继承关系

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

二、成员变量

transient int size = 0;//LinkedList存放的元素个数
transient Node<E> first;//首结点
transient Node<E> last;//尾结点

其中class Node<E>是LinkedList中的一个静态嵌套类，结构如下：

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

三、ListIterator迭代器

通用的迭代器接口只提供如下四个方法：

  1. hasNext
  2. next
  3. remove
  4. default forEachRemaining(Consumer<? super E> action)//Consumer是函数式接口 LinkedList由于是序列式容器，所以它的迭代器实现的是ListIterator接口，相对于Iterator接口，它多了如下方法：
  • hasPrevious
  • previous
  • nextIndex:返回当前迭代器所指向的结点的下标
  • previousIndex:返回当前迭代器所指向的结点的前一个结点下标
  • set:设置当前迭代器所指向的结点的上一个结点的值
  • add:在当前迭代器所指向的结点前插入一个新结点

LinkedList内部的迭代器源码如下所示：

private class ListItr implements ListIterator<E> {
    /*lastReturned代表当前迭代器所指向的结点的上一个结点，它有如下特点和功能
        1.迭代器初始化时该变量为null
        2.add/remove操作，会将其设置为null
        3.调用remove和set方法时会首先检查该变量是否为null,若为null,则抛异常
        4.执行next方法时，lastReturned = next;next = next.next；
        5.根据1，2，3点，可知Java是如何保证remove只能在next方法之后执行
    */
    private Node<E> lastReturned;
    private Node<E> next;//当前迭代器所指向的结点
    private int nextIndex;//当前结点的下标
    private int expectedModCount = modCount;
    /*
        1.expectedModCount变量表示的是通过迭代器修改LinkedList结构的次数（包括增加/删除结点，不包括修改某一结点的值），初试值设置为modCount(当前修改LinkedList结构的次数)
        2.在add/remove方法中都会对modCount++(LinkedList内部方法中实现，如linklast,linkbefore,unlink等)，同时也会对expectedModCount++
        3.该迭代器提供一个并发操作的检查函数checkForComodification，内部会判断expectedModCount与modCount是否相等，若不相等，则抛出异常ConcurrentModificationException
        4.next和previous方法在一开始就会调用checkForComodification方法进行检查，这意味着：
            A.在一个线程中：不能在使用一个迭代器遍历的同时，使用另一个迭代器或LinkedList方法对集合结构进行修改（因为修改结构会导致modCount++，但是原迭代器只是在遍历，expectedModCount不变）
            B.在不同的线程中，不能一个线程在遍历，另一个线程在修改，原理同上。
    */
    ListItr(int index) {
        // assert isPositionIndex(index);
        next = (index == size) ? null : node(index);
        nextIndex = index;
    }
    public boolean hasNext() {
        return nextIndex < size;
    }
    public E next() {
        checkForComodification();
        if (!hasNext())
            throw new NoSuchElementException();

        lastReturned = next;
        next = next.next;
        nextIndex++;
        return lastReturned.item;
    }
    public boolean hasPrevious() {
        return nextIndex > 0;
    }
    public E previous() {
        checkForComodification();
        if (!hasPrevious())
            throw new NoSuchElementException();

        lastReturned = next = (next == null) ? last : next.prev;
        nextIndex--;
        return lastReturned.item;
    }
    public int nextIndex() {
        return nextIndex;
    }

    public int previousIndex() {
        return nextIndex - 1;
    }
    public void remove() {
        checkForComodification();
        if (lastReturned == null)
            throw new IllegalStateException();
        Node<E> lastNext = lastReturned.next;
        unlink(lastReturned);
        if (next == lastReturned)
            next = lastNext;
        else
            nextIndex--;
        lastReturned = null;
        expectedModCount++;
    }
    public void set(E e) {
        if (lastReturned == null)
            throw new IllegalStateException();
        checkForComodification();
        lastReturned.item = e;
    }
    public void add(E e) {
        checkForComodification();
        lastReturned = null;
        if (next == null)
            linkLast(e);
        else
            linkBefore(e, next);
        nextIndex++;
        expectedModCount++;
    }
    public void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (modCount == expectedModCount && nextIndex < size) {
            action.accept(next.item);
            lastReturned = next;
            next = next.next;
            nextIndex++;
        }
        checkForComodification();
    }
    final void checkForComodification() {//并发操作检查
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

四、内部重要函数

LinkedList设计了add/remove等函数可以对链表结构进行修改，同时也支持通过ListIterator的add/remove对表结构进行修改，这些函数调用的真正实现功能的函数如下所示：

对应增加结点：

  • void linkFirst(E e)
  • void linkLast(E e)
  • void linkBefore(E e,Node succ) 对应删除结点的
  • unlinkFirst(Node f)
  • unlinkLast(Node l)
  • unlink(Node 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++;
}
oid 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;
}

五、LinkedList与C++stl中的list进行比较

相同点：

  • 都是双向链表
  • 都可以对链表的结构进行修改（新增或删除结点），Java使用add/remove函数，C++使用insert/erase函数（push_back,push_front,pop_back,pop_front也是这两种函数实现）
  • 都可通过迭代器对链表进行正/反向遍历，且允许通过迭代器对结点的值进行修改 不同点：
  • C++是双向循环链表，Java只是双向链表
  • C++拥有一个头结点，增加这个结点后插入和删除操作就统一了；Java没有设计头结点，因此LinkedList中有first和last两个结点表示首尾，同时插入和删除操作需要考虑首尾的因素
  • Java允许通过迭代器对LinkedList的结构进行修改（插入/删除结点），C++中的迭代器没有此功能
  • Java通过listIterator(index)方法可获取任意位置的迭代器；C++只能通过begin()/end()获取首/尾迭代器
avatar
文章
阅读
粉丝