LinkedList<E>源码详解

LinkedList<E>源码详解(基于jdk1.8.0_162)

说明：LinkedList<E>底层是用双链表的方式实现，比较适合add和remove操作场景较多的情况。

           线性结构包括数组、单链表、双链表、环性链表、栈等，可参考Java数据结构的文章。

双链表结构图（类似于自行车链条，一环扣一环）：

 

一）类图

LinkedList<E>继承了AbstractSequentialList<E>抽象类，实现了add、remove、set等功能。

LinkedList<E>继承了List<E>接口，依赖与Iterator<E>和ListIterator<E>接口，实现了数据迭代等功能。

LinkedList<E>继承了Deque<E>接口，可以实现双队列的一些操作。

备注：如需自己实现LinkedList<E>类似的功能，可以继承LinkedList<E>的父类，然后再自定义方法。

 

二）构造方法

1）LinkedList()，初始化一个集合对象

2）LinkedList(Collection<? extends E> c)，构造一个指定元素集合的列表，其实就是调用了addAll(Collection<? extends E> c)方法

// 主要数据结构
transient Node<E> first; // 指向头部元素指针
transient Node<E> last;  // 指向尾部元素指针
transient int size = 0;  // 集合的元素个数，默认为0

// 双链表结构
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;
    }
}

 

三）添加

1）offer(E e)，在尾部添元素

     add(E e)，在尾部添元素

     offerLast(E e)，在尾部添元素

     addLast(E e)，在尾部添元素

public boolean offer(E e) {
    return add(e);
}

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

public boolean offerLast(E e) {
    addLast(e);
    return true;
}

public void addLast(E e) {
    linkLast(e);
}

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

2）offerFirst(E e)，在头部添加元素

     push(E e)，在头部添加元素

     addFirst(E e)，在头部添加元素

public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}

public void push(E e) {
    addFirst(e);
}

public void addFirst(E e) {
    linkFirst(e);
}

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

3）add(int index, E element)，在指定的index位置，添加新元素

public void add(int index, E element) {
    checkPositionIndex(index); // 判断index是否在0和size之间，验证index的有效性

    if (index == size) // 如果两个值相等，就相当于在尾部添加新元素
        linkLast(element); // 调用尾部添加元素方法
    else
        linkBefore(element, node(index)); // 先调用node方法，找到需要插入元素的位置，再调用插入元素方法
}

Node<E> node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) { // size>>1相当于把元素分成两半,判断index在那一边,可减少一半元素的查找
        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) {
    // 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++;
}

4）addAll(Collection<? extends E> c)，添加一个指定元素集合的列表

     addAll(int index, Collection<? extends E> c)，在指定index下标位置，添加一个指定元素集合的列表

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

 

四）查找

1）get(int index)，根据指定index下标查找元素，元素不存在会报错

2）getFirst()，获取列表中第一个元素

      element()，获取列表中第一个元素，调用了getFirst()方法

      peek()，获取列表中第一个元素，元素不存在返回null

      peekFirst()，获取列表中第一个元素，元素不存在返回null

3）getLast()，获取列表中最后一个元素，元素不存在会报错

      peekLast()，获取列表中最后一个元素，元素不存在返回null

4）indexOf(Object o)，根据指定元素的值，从头部元素中开始查询第一个出现的元素返回

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

5）lastIndexOf(Object o)，根据指定元素的值，从尾部元素中开始查询第一个出现的元素返回

public int lastIndexOf(Object o) { // 相当于数组中的倒序遍历查找元素
    int index = size;
    if (o == null) {
        for (Node<E> x = last; x != null; x = x.prev) {
            index--;
            if (x.item == null)
                return index;
        }
    } else {
        for (Node<E> x = last; x != null; x = x.prev) {
            index--;
            if (o.equals(x.item))
                return index;
        }
    }
    return -1;
}

 

五）修改

1）set(int index, E element)，修改指定index下标位置的元素，替换成element

public E set(int index, E element) {
    checkElementIndex(index); // 校验index是否有效
    Node<E> x = node(index); // 根据index查询到需要替换的元素
    E oldVal = x.item; // 获取需替换元素的值，作为返回值
    x.item = element; // 替换成新元素element
    return oldVal;
}

 

六）删除

1）remove()，查找到第一个元素，并删除

      pop()，查找到第一个元素，并删除

      removeFirst()，查找到第一个元素，并删除，元素不存在会报错

      poll()，查找到第一个元素，并删除

      pollFirst()，查找到第一个元素，并删除，元素不存在返回null

public E remove() {
    return removeFirst();
}

public E pop() {
    return removeFirst();
}

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

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

public E pollFirst() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

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

2）removeLast()，找到最后一个元素，并删除，元素不存在报错

     pollLast()，找到最后一个元素，并删除，元素不存在返回null

public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}

public E pollLast() {
    final Node<E> l = last;
    return (l == null) ? null : unlinkLast(l);
}

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

 

七）迭代

备注：LinkedList<E>的迭代方式和ArrayList<E>、Vector<E>一样。

 

八）总结

1、LinkedList<E>底层是用双链表的方式实现。

2、LinkedList<E>比较适合add和remove操作场景较多的情况，根据元素查找到位置，只需要改变元素的prev和next指向。

3、根据LinkedList<E>的特性，可以做各种效果，比如说需获取一个元素，可以调用返回值为null的方法，也可以调用返回值报错的方法。

 

识别二维码关注个人微信公众号

本章完结，待续，欢迎转载！
 
本文说明：该文章属于原创，如需转载，请标明文章转载来源！