JDK1.8源码解析-LinkedList

类关系图

 类属性

//列表大小
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;
    }
}

由类的属性可以看出linkedlist底层是一个双端链表，链表的每个mode既有前驱指针prev，又有后继指针next：

构造函数

/**
 * 构造空列表.
 */
public LinkedList() {
}

/**
 * 构造一个包含特定集合的列表
 */
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

对链表进行操作的方法

首尾结点的删除添加

双端链表的首位元素添加删除操作。

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; // 后继结点设为空
    first = next;//头指针后移
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

/**
 * 不连接最后结点l
 */
private E unlinkLast(Node<E> l) {
    final E element = l.item;//获取尾节点中的元素
    final Node<E> prev = l.prev;//获取尾结点的前驱结点
    l.item = null;//元素设为空
    l.prev = null; // 尾节点的前驱指针设为空，帮助GC回收
    last = prev;//尾节点前移
    if (prev == null)//前驱结点为空，则列表为空
        first = null;//首节点设为空
    else
        prev.next = null;//前驱结点不为空，则将前驱结点的后继节点设为空
    size--;//列表大小-1
    modCount++;
    return element;
}

/**
 * 在列表首部添加元素
 */
private void linkFirst(E e) {
    final Node<E> f = first;//获取当前的首节点
    final Node<E> newNode = new Node<>(null, e, f);//新节点的前驱为null，后继为f。
    first = newNode;//移动头指针
    if (f == null)//如果列表为null
        last = newNode;//尾指针指向新节点
    else
        f.prev = newNode;//不为空时原来的头节点前驱指向新节点
    size++;
    modCount++;
}
/**
 *在列表尾部插入元素
 */
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++;
}

在任意位置添加结点

在链表中的任意位置添加元素。

/**
 * 在一个非空结点前添加元素
 */
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    final Node<E> pred = succ.prev;//获取结点succ前驱结点
    final Node<E> newNode = new Node<>(pred, e, succ);//新结点的前驱为succ前驱结点，后继为succ
    succ.prev = newNode;//succ的前驱为新结点
    if (pred == null)//前驱为空
        first = newNode;//头指针指向新结点
    else
        pred.next = newNode;//不为空，前驱的后继结点设为新节点。
    size++;
    modCount++;
}

删除任意位置的元素

在链表中的任意位置删除元素。

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;//获取前驱结点
//将x的前驱结点设为空
    if (prev == null) {//前驱为空
        first = next;//头指针指向后继
    } else {
        prev.next = next;//不为空前驱结点的后继为后继节点
        x.prev = null;//结点的pre设为空
    }
//将x的后继节点设为空
    if (next == null) {//后继为空
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

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

查找相应位置的结点

返回node在链表中的位置。

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

删除首节点、尾节点

/**
 * Removes and returns the first element from this list.
 *
 * @return the first element from this list
 * @throws NoSuchElementException if this list is empty
 */
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 void addFirst(E e) {
    linkFirst(e);
}

/**
 * 在尾部追加元素
 */
public void addLast(E e) {
    linkLast(e);
}

在特定位置插入元素

private boolean isPositionIndex(int index) {//下标是否违法
    return index >= 0 && index <= size;// 插入位置可以是尾节点的下个结点
}
private void checkPositionIndex(int index) {//下标位置违法抛出异常
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
public void add(int index, E element) {
    checkPositionIndex(index);//检查越界

    if (index == size)//index在尾部
        linkLast(element);
    else//没有在尾部
        linkBefore(element, node(index));//插入相应节点的前驱
}

在特定位置插入集合

public boolean addAll(int index, Collection<? extends E> c) {
    checkPositionIndex(index);//下标是否违法

    Object[] a = c.toArray();//集合转数组
    int numNew = a.length;
    if (numNew == 0)//数组长度为0，添加失败
        return false;

    Node<E> pred, succ;
    if (index == size) {//插入位置为根节点
        succ = null;
        pred = last;
    } else {
        succ = node(index);//找到位置为index的结点取出
        pred = succ.prev;//找到前驱结点
    }

    for (Object o : a) {//遍历插入
        @SuppressWarnings("unchecked") E e = (E) o;
        Node<E> newNode = new Node<>(pred, e, null);//当前结点的前驱指向pre，后继为null
        if (pred == null)//前驱结点为空
            first = newNode;//头指针指向该节点
        else
            pred.next = newNode;//前驱结点的后继结点指向当前节点
        pred = newNode;//前驱结点变为当前结点
    }

    if (succ == null) {//如果succ为空，尾指针指向前驱结点
        last = pred;
    } else {//否则将succ连接到插入的最后一个结点
        pred.next = succ;
        succ.prev = pred;
    }

    size += numNew;
    modCount++;
    return true;
}

返回结点下标

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++;//下标+1
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))//元素相等，返回下标
                return index;
            index++;
        }
    }
    return -1;
}

根据值删除结点

/**
 * 移除链表中元素第一次出现的结点
 */
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;
}

删除相应位置的元素

private boolean isElementIndex(int index) {//检查元素下标
    return index >= 0 && index < size;//删除位置不能超过尾元素
}

private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

public E remove(int index) {
    checkElementIndex(index);//检查位置越界
    return unlink(node(index));//删除结点
}

栈操作

用双端链表模拟栈操作。

public E peek() {//获取首元素
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}
public E pop() {//删除首元素
    return removeFirst();
}
public void push(E e) {//添加首元素
    addFirst(e);
}

队列操作

用双端链表模拟队列。

public E poll() {//取出队首元素
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}
public boolean offer(E e) {//插入队尾
    return add(e);
}

双端队列操作

双端链表特有的操作。

public boolean offerFirst(E e) {//插入队首元素
    addFirst(e);
    return true;
}

public boolean offerLast(E e) {//插入队尾元素
    addLast(e);
    return true;
}

public E peekFirst() {//获取队首元素
    final Node<E> f = first;
    return (f == null) ? null : f.item;
 }

public E peekLast() {//获取队尾元素
    final Node<E> l = last;
    return (l == null) ? null : l.item;
}

public E pollFirst() {//取出队首元素
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}
public E pollLast() {//获取队尾元素
    final Node<E> l = last;
    return (l == null) ? null : unlinkLast(l);
}