LinkedList源码解读

LinkedList源码分析

1.LinkedList简介

1.1 概述

LinkedList本质上是一个双向链表，列表中的每个节点都包含了对前一个指针和后一个指针的引用，适用于增删频繁但是查找不频繁的场景，线程不安全，适用于单线程。

1.2 继承关系

继承关系如下图所示：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OOqDWdzm-1578131489305)(en-resource://database/4136:1)]

LinkedList 是一个继承于AbstractSequentialList的双向链表。LinkedList 可以被当作堆栈、队列或双端队列进行操作。
LinkedList 实现 List 接口，所以能对它进行队列操作。
LinkedList 实现 Deque 接口，能将LinkedList当作双端队列使用。
LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
LinkedList 实现java.io.Serializable接口，所以LinkedList支持序列化，能通过序列化去传输。
————————————————
版权声明：本段为CSDN博主「GhostSugar」的原创文章。
原文链接：https://blog.csdn.net/weixin_42139757/article/details/82108515

2.LinkedList源码分析

2.1 类中属性

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    // list大小
    transient int size = 0;

    /**
     * 链表头节点
     */
    transient Node<E> first;

    /**
     * 链表尾节点
     */
    transient Node<E> last;
    
    // 内部类，链表结点类
    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;
        }
    }
}

2.2 构造方法

/**
 * 构造一个空链表
 */
public LinkedList() {
}

/**
 * 构造一个包含指定集合的链表，按集合顺序返回链表
 */
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

2.3 核心方法

2.3.1 add()方法

/**
 * 在链表尾部添加指定元素
 */
public boolean add(E e) {
    linkLast(e);
    return true;
}

/**
 * 将e链接为最后一个元素
 */
void linkLast(E e) {
    final Node<E> l = last;
    // l:当前链表最后一个结点，e:要添加结点值，null:链表最后结点的下一个为空
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    // 如果最后一个结点为空，则表示当前结点为第一个结点
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}


/**
 * 指定下标添加元素
 */
public void add(int index, E element) {
	// 检查下标是否越界
    checkPositionIndex(index);
    // 如果当前下标等于链表长度，在链表末尾添加
    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

/**
 * 返回指定元素索引处的（非空）节点。
 */
Node<E> node(int index) {
	// 判断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;
    }
}

/**
 * 在非空结点succ前插入元素e
 */
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++;
}

2.3.2 remove()方法

/*
 * 按照索引删除结点
 */
public E remove(int index) {
    checkElementIndex(index);
    // node()方法根据索引返回要删除的结点
    return unlink(node(index));
}

/*
 * 按照值来删除索引
 */
public boolean remove(Object o) {
    if (o == null) {
        for (LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

/**
 * 移除非空结点x
 */
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;
}

2.3.3 set()方法

public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

2.3.4 get()方法

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

/**
 * 返回指定元素的第一个匹配项的索引
 */
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;
}