LinkedList源码分析

简介

双向链表，线程不安全，在内存中不连续存储，不仅实现了List接口，也实现了Deque接口；

transient Node first;头结点
transient Node last;尾节点

插入操作：

add(E e)：在链表尾节点后插入新的节点，作为尾结点；

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

void linkLast(E e) {
    final Node<E> l = last;
	//创建一个新节点，并且其prev引用指向尾结点；
    final Node<E> newNode = new Node<>(l, e, null);
	//尾结点重新赋值
    last = newNode;
	//如果原尾结点为null,说明头结点first也是null,为first节点赋值；
    if (l == null)
        first = newNode;
	//原尾节点不为null,将其next引用指向newNode节点；
    else
        l.next = newNode;
    size++;
    modCount++;
}

add(int index, E element)：在指定位置插入新节点；

public void add(int index, E element) {
	//index越界判断；
    checkPositionIndex(index);
	//如果是在链表节点后插入新节点，和add(E e)操作一样；
    if (index == size)
        linkLast(element);
    else
		//先找到index对应的节点x，再在x节点前插入新节点；
        linkBefore(element, node(index));
}

//index小于size/2,则从链表头结点向后遍历，查找对应节点；否则从链表尾结点向前遍历查找对应节点；
Node<E> node(int index) {
    // assert isElementIndex(index);
	
    if (index < (size >> 1)) {
		//index 为0是直接返回first节点;
        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之前插入新的节点；
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
	//得到succ节点的上一个节点pred；
    final Node<E> pred = succ.prev;
	//创建新的节点，其pred引用指向pred，succ节点指向succ节点；
    final Node<E> newNode = new Node<>(pred, e, succ);
	//succ节点的prev引用指向newNode；
    succ.prev = newNode;
	//pred为null说明在链表头结点之前插入新节点；将头结点first重新赋值；pred不为null,将节点pred的next引用指向newNode；
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

addFirst():插入新节点，作为头结点；

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

private void linkFirst(E e) {
    final Node<E> f = first;
	//创建一个新节点，其next引用指向头结点；
    final Node<E> newNode = new Node<>(null, e, f);
	//将头结点重新赋值；
    first = newNode;
	//原头结点为null,说明last节点也是null,为last节点赋值；原头结点不为空，将其pred引用指向newNode;
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}

addLast():和add(E e)完全一样；

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

addAll():在链表尾结点后添加；

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;
	//index == size 则意味在尾结点后插入新节点；不等，则在index对应节点前，插入;
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }
	//遍历数组a;
    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
		//创建新节点，其pred引用指向pred节点;
        Node<E> newNode = new Node<>(pred, e, null);
		//如果pred节点为null,说明succ节点为头结点，重新为first节点赋值；pred不为null,将pred节点的next引用指向newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
		//为pred重新赋值；
        pred = newNode;
    }
	//succ节点为null,说明是在尾结点后插入新节点，为last节点重新赋值；succ不为null,将pred节点的next引用指向succ,succ节点的pred引用指向pred节点;
    if (succ == null) {
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }

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

以上就是插入的主要操作过程；

查询和修改操作

查询操作：get():

public E get(int index) {
	先进行index校验，是否满足index>=0 && index<size；再根据index遍历找到对应节点，返回该节点存储的元素值；
    checkElementIndex(index);
    return node(index).item;
}

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

改操作：重新赋值；

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

删除操作：

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节点赋值；
    first = next;
	//如果next节点为null,说明删除前该链表只有一个节点，则将last节点也制null；否则，将next节点的pred引用制null;
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

removeLast():删除尾结点；

public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return 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节点重新赋值；
    last = prev;
	//如果pred节点为null,说明链表再删除之前只有一个节点，为first节点重新赋值为null；否则，将prev节点的next引用制null;
    if (prev == null)
        first = null;
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}

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

E unlink(Node<E> x) {
    // assert x != null;
	//获取当前节点x的 对应的值，下一个节点next,上一个节点prev;
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;
	//节点prev为null,说明当前x是头结点，重新为first节点赋值；不为null,将prev节点的next引用指向next节点，并将x节点的prev引用制null；
    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }
	//节点next为null,说明当前节点x是尾结点，重新为last节点赋值；不为null,将next节点的prev引用指向prev节点，并将x节点的next引用制null;
    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }
	//将x节点对应的值制null;
    x.item = null;
    size--;
    modCount++;
    return element;
}

总结

插入和删除效率:插入，删除头尾节点的时候，效率为O(1);为中间节点的时候为O(n)；

查询：查询头尾节点时，效率为O(1)，为中间节点时为O(n)；
根据index插入时，都要调用node(index)找到对应的node；在进行具体操作；
就LinkedList本身来说，增删改查各种操作效率接近；

ArrayList 和 LinkedList相比较；
ArrayList 查询快，增删慢（可能多次移动数组(即扩容，增删)）；
LinkedList 查询慢（需要遍历），增删快；

如有问题，请多指教，谢谢！