LinkedList源码解析

Dx
482 阅读8分钟

前言

本文是LinkedList源码解析，本文包含了双边指向，List接口实现原理，元素定位原理，克隆机制等解析。

简介

  • LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。

  • 继承于AbstractSequentialList，默认实现了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)这些函数。这些接口都是随机访问List的，虽然LinkedList可以调用这些方法，但是内部实现其实是不支持随机访问的，都是顺序迭代实现的。

  • 实现 List 接口，能对它进行队列操作。

  • 实现 Deque 接口，即能将LinkedList当作双端队列使用。

  • 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。

  • 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。

  • 是非同步的。

    关系如下：

    java.lang.Object
   ↳     java.util.AbstractCollection<E>
         ↳     java.util.AbstractList<E>
               ↳     java.util.AbstractSequentialList<E>
    				↳     java.util.LinkedList<E>

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

    java集合框架图如下：

问题

  1. 如何实现的List接口的功能
  2. 内部节点的结构
  3. 为什么插入效率高
  4. 需要扩容么
  5. 拷贝方式

带着问题开始解析，打开源码，我们先从属性入手。

一、LinkedList属性解析

我们跟踪源码看到如下属性

transient int size = 0;
transient Node<E> first;
transient Node<E> last;
private static final long serialVersionUID = 876323262645176354L;

1.size

​ 此属性为大小

2.first

​ 此属性为指向第一个节点的指针

3.last

​ 此属性为指向最后一个节点的指针

4.serialVersionUID

​ 此属性是序列化UID，Java序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。 在进行反序列化，Java虚拟机会把传过来的字节流中的serialVersionUID和本地相应实体类的serialVersionUID进行比较， 如果相同就认为是一致的实体类，可以进行反序列化，否则Java虚拟机会拒绝对这个实体类进行反序列化并抛出异常。

  • 要注意first，last，size属性都用transient关键字修饰，transient用来表示一个域不是该对象序行化的一部分，当一个对象被序行化的时候，transient修饰的变量不会被序列化。
  • 用此修饰符其实是为了提高性能，因为首尾节点在未被添加元素时都是未使用空间，如果这些空间也序列化，其实是无意义的。那么我们知道LinkedList其实是实现了序列化的，序列化和反序列化的实现其实writeObject(),readObject()这两个方法，我们下文有解析。

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

Node类包含了自己节点和前后两个节点的指针。要注意的是，此类为内部静态类，只供LinkedList内部使用。

我们先简单对属性做了说明，下面跟随思路通过构造函数进行解析。

二、LinkedList方法解析

一、构造方法

跟踪源码看到如下代码

//空构造
 public LinkedList() {}

首先看到，LinkedList有两个构造，我们逐个解析

1.LinkedList()

  1. 空构造实现，因为LinkedList是双向列表，所以每次添加元素只需要给末尾元素的next节点添加新元素的指针，并把原先末尾元素给新末尾元素的prev节点赋值即可。所以不需要默认开辟容器大小。

2.LinkedList(Collection<? extends E> c)

//传入集合的构造
public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
 }
  1. 此方法可以传入一个实现了Collection的E的子类，构造一个列表，该列表包含指定集合的元素，其顺序由集合的迭代器返回。
  2. 其实就是调用了addAll(Collection<? extends E> c)方法，我们下文做解析

二、添加方法

添加方法有多个，我们逐个解析，首先我们直接看addAll()方法，方法内部基本包含了add的所有逻辑

1.addAll(Collection<? extends E> c)|addAll(int index, Collection<? extends E> c)

  1. 方法内部调用了 addAll(int index, Collection<? extends E> c)方法，下标为size（也就是末尾元素添加）。

    //多元素添加
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;
}

  2. 首先会调用checkPositionIndex(index)方法验证下标合法性，最终调用到isPositionIndex(int index)方法，代码如下

    //验证下标合法性
private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//验证下标合法性
private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}
    • 其实就是验证传入的下标是否在0至size之间，不符合条件则抛出异常。

  3. 用Collection.toArray()方法得到一个对象数组，并得到数组的长度，如果长度为0则直接return。

  4. 创建pred, succ两个节点。

  5. 此时有两个分支，我们先看元素末尾添加情况（传入下标==size，在LinkedList创建完毕直接调用addAll则进入此分支）

    6.1. 把最后的节点给pred赋值

    6.2. 对传入的集合迭代，做出如下操作

    • 每一次迭代都创建一个Node节点
    • 把pred指向之前的节点
    • 如果pred为空，则新节点为首个节点（first）
    • 对pred赋值，让其指向newNode，至此newNode与前节点的双边指向关系建立
    • 对pred赋值，newNodeo为即将插入节点的前节点，在一个循环中，newNode将建立与后节点的双边指向关系
    • 最终建立最后一个节点的指向

  6. 分支二（此分支为指定下标添加）：

    7.1.通过node(int index)找到对应节点，赋值给succ

    //通过下标查找节点
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;
    }
}
    • 通过传入的index判断是否小于size的一半（size >> 1），如果小于则从头开始遍历，通过遍历对象的next（下一个节点）指向确定到对应的下标元素，并返回
    • 如果大于size的一半（size >> 1）则从尾开始便利，通过遍历对象的prev（上一个节点）指向确定到对应的下标元素，并返回

    7.2.对pred赋值为succ的prev节点，之后步骤同6.2

    7.3.pred的next节点指向为succ，并把succ的prev节点指向pred，建立双边指向关系。

2.add(E e)

//元素添加
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++;
}

  1. add()其实是调用了linkLast()方法

  2. 创建新Node节点，把last指向至新节点的prev

  3. 把last节点赋值为新Node节点

  4. 如果last节点为空则新Node节点为first，否则原last节点的下一个节点为新Node

  5. size自增，modCount自增（Fail-Fast机制，具体解释可查看ArrayList源码解析）

    add(e)方法和addLast(E e)其实是一样的，只不过前者返回了Boolean值

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

    还有一个方法为linkFirst(E 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++;
}

    原理和linkLast()基本一致

3.add(int index, E element)

public void add(int index, E element) {
        checkPositionIndex(index);
        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
}

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++;
}
  1. 下标合法性检查
  2. 如果传入的下标==size则直接调用addLast()
  3. 否则通过node方法定位元素，调用linkBefore()
  4. 下标位元素替换（创建新Node并把prev指针指向定位到的节点的prev，next节点指向定位到的节点）
  5. 下标位原元素后移（把原元素的prev指向新节点）
  6. size自增，modCount自增

4.等价方法

LinkedList还提供了一些等价方法，区别在于有些返回了Boolean值

  • push(E e)等价于addFirst(E e)等价与linkFirst(E e)
  • offer(E e)等价与add(e)
  • offerFirst(E e)等价于addFirst(e)
  • offerLast(E e)等价与addLast(e)

总结

​ 本节重点如下：

  • 下标寻找对应元素会比较index和双向链表长度的1/2，若前者大，则从链表头开始往后查找，直到index位置。否则，从链表末尾开始先前查找，直到index位置。
  • 传入集合的构造最终调用了addAll()方法，内部实现为添加的元素的双边关系建立

关键词

​ 双边关系建立，获取元素方式

三、删除方法

1.remove()

//删除首位元素
public E remove() {
        return removeFirst();
    }

public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return 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;
    }
  1. 验证first元素是否为空，为空则抛出异常
  2. 调用unlinkFirst()方法实现
  3. 把first内元素和指针全部归null，可供GC回收
  4. 把原first原色的next指针赋值给first
  5. size自减，modCount自增
  6. 返回删除元素

LinkedList还提供了removeLast()方法，内部调用了unlinkLast()，和removeFirst()基本一致

LinkedList还提供了pop()方法，内部只是调用了removeFirst()。还有pollFirst()和pollLast()方法，为删除首个活尾部元素。

2.remove(int index)

//通过下标元素删除
public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
}

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;
    }
  1. 验证下标合法性，不合法抛出异常
  2. 通过node(index)方法获得元素（解析在上文）
  3. 如果获得元素为首个元素，则把获取元素的next赋值给first
  4. 删除获得的元素的对应元素的指向（把通过下标获得元素的prev指针指向元素的next）
  5. 如果获得的元素为末尾元素，则把获取元素的prev赋值给last
  6. 设置获取元素的item为null，方便GC
  7. size自减，modCount自增
  8. 返回对应元素

3.remove(Object o)

//元素删除
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;
    }

  1. 和ArrayList的元素删除很像，只不过是通过next指针进行迭代

  2. 最终调用unlink()方法（上文有解析）

    只删除首个匹配到的元素（null也支持）

    LinkedList还提供了removeFirstOccurrence(Object o)，其实也是调用remove(o)方法

    LinkedList还提供了removeLastOccurrence(Object o)，区别只是是通过prev指针进行倒叙迭代。

四、获取方法

1.element()

//获取首位元素
public E element() {
      return getFirst();
}

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

  1. 判断first是否为空，如果为空则抛出NoSuchElementException异常，不为空则返回。

    LinkedList还提供了getLast()方法，返回末尾元素，内部实现思路和getFirst()基本一致。

    LinkedList还提供了peek()方法，和element()区别在于如果first为空，则返回null。peekFirst()方法和peek()效果一致。peekLast()则为获取末尾元素

2.get(int index)

//通过下标获取元素
public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
}
  1. 检查下标是否合法，不合法则抛出异常（上文有解析）
  2. 通过node()返回对应节点，然后返回item（node方法上文有解析）

五、其他方法

1.size()

获取LinkedList元素个数

 public int size() {
        return size;
}

2.toArray()

获取数组

public Object[] toArray() {
        Object[] result = new Object[size];
        int i = 0;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
        return result;
}
  1. 根据size初始化result的容量
  2. 通过next指针迭代添加元素至result数组

总结

  1. LinkedList实际上是通过双向链表去实现的。既然是双向链表，那么它的顺序访问会非常高效，而随机访问效率比较低
  2. LinkedList内部实现了Node类。Node是双向链表节点所对应的数据结构，它包括的属性有：当前节点所包含的值，上一个节点的指针，下一个节点的指针。
  3. LinkedList实现了List接口，原理非常简单，它就是通过一个计数索引值来实现的。寻找对应元素会比较index和双向链表长度的1/2，若前者大，则从链表头开始往后查找，直到index位置。否则，从链表末尾开始先前查找，直到index位置。
  4. LinkedList的克隆函数，即是将全部元素克隆到一个新的LinkedList对象中
avatar
文章
阅读
粉丝
相关推荐
搞懂 Java LinkedList 源码
8.6k阅读
 · 
140点赞
LinkedList 源码解析
1.7k阅读
 · 
8点赞
LinkedList源码解析
1.3k阅读
 · 
6点赞
LinkedList源码解析
1.2k阅读
 · 
5点赞
LinkedList 源码分析
914阅读
 · 
3点赞
LinkedList源码解析
953阅读
 · 
1点赞
LinkedList 源码解析
797阅读
 · 
8点赞
LinkedList源码分析
880阅读
 · 
2点赞
LinkedList 源码学习
837阅读
 · 
2点赞
LinkedList 源码解析
504阅读
 · 
4点赞

友情链接：