LinkedList源码分析

属性

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

transient int size = 0;

/**
* 属性只放头尾节点，要注意更新
*/

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

/**
 * 尾结点
 */
transient Node<E> last;

扩展

transient

1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。
2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。
3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

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

构造方法

/**
 * 无参初始化
 */
public LinkedList() {
}

/**
 * 调用无参，并加入集合
 */
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

增删改查

注意事项

对空链表进行删查会异常

增

/**
 * Links e as first element.
 */
private void linkFirst(E e) {
    //原first节点
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    //原first节点为空，说明是空链表，不需要进行地址的改变，设置first和last节点都为节点e
    if (f == null)
        last = newNode;
    else
        //更新原first节点上一个（prev）节点地址
        f.prev = newNode;
    size++;
    modCount++;
}

/**
 * Links e as last element.
 *
 * 基本与上同
 */
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    //last节点为空，说明是空链表，不需要进行地址的改变，设置first和last节点都为节点e
    if (l == null)
        first = newNode;
    else
        //更新原last节点下一个节点
        l.next = newNode;
    size++;
    modCount++;
}

/**
 * Inserts element e before non-null Node succ.
 * 
 * 在非null节点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;
    //开始衔接链表
    //succ是first节点，因为在非空节点之前，不需要检查last节点
    if (pred == null)
        first = newNode;
    else
        //更新前节点的next
        pred.next = newNode;
    size++;
    modCount++;
}


/**
 * 加到头节点
 */
public void addFirst(E e) {
    linkFirst(e);
}

/**
 * 加到尾结点
 */
public void addLast(E e) {
    linkLast(e);
}

/**
 * 默认加到为节点
 */
public boolean add(E e) {
    linkLast(e);
    return true;
}

/**
 * 加到下标位置
 */
public void add(int index, E element) {
    checkPositionIndex(index);

    //确定增加方式
    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

删

/**
 * Unlinks non-null first node 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
        //删除prev节点信息，gc回收
        next.prev = null;
    size--;
    modCount++;
    return element;
}

/**
 * Unlinks non-null last node 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;
}

/**
 * Unlinks non-null node 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;

    //是first节点
    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    //last节点
    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}


/**
 * 删第一个
 */
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

/**
 * 删最后一个
 */
public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}

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

/**
 * 根据下标删
 */
public E remove(int index) {
    checkElementIndex(index);
    //会传入对应下标的节点
    return unlink(node(index));
}

删除last和first节点需要传参

获取对应下标节点

/**
 * Returns the (non-null) Node at the specified element index.
 */
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;
    }
}

改

/**
 * 直接修改节点数据
 */
public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

查

/**
 * 查头节点
 */
public E getFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}

/**
 * 查尾结点
 */
public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}