java基础教程：集合LinkedList

LinkedList得UML图，实现了Cloneable，list，Deque，Serializable接口，继承父类AbstractSequentiaList。

Deque接口，新增了链表得一些特色方法，offer，poll，peek，element等

LinkedList基本重写了AbstractList中的所有基本方法。

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

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

    /**
     * Constructs an empty list.
     */
    public LinkedList() {
    }

LinkedList有3个成员变量，size保存了当前链表的大小，first链表第一个元素引用，last链表最后一个元素引用，

初始值first=last=null

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

 

保留了当前元素类容，下一个元素引用next，前一个元素引用，当Node是链表第一个元素时候first=Node且prev=null

Node是参数无get和set方法，是一个不可变对象，当一个线程操作Node时，赋值是一个原子操作。

方法解析：

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

add方法默认从链表尾部添加元素，将尾部last赋值给l如果l==null，链表为空，添加的为第一个元素，链表first=last=newNode

如果l！=null将最后一个元素的next复制为newNode，last复制为newNode，size++。

get（int index）方法：

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

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个元素，先检查index是否越界。

接着调用node方法，判断index在size/2的左边还是右边，在左边就从链表头开始遍历，否则从链表尾部开始遍历。

poll()返回链表第一个元素值，并删除第一个元素。

peel()返回链表第一个元素值，不做删除操作。

push(E e)链表尾部添加一个元素。

小结：

LinkedList是一种非线程安全的双链表，无论从链表头部还是尾部都可以遍历整个链表。

链表在做新增和删除操作的时候只需要调整链表Node元素中的next和prev的引用值就可以实现链表的新增和删除，这就是LinkedList在做新增和删除操作的时候比ArrayList快的原因，ArrayList需要扩容，扩容需要复制。

链表在做查询的时候，无法像ArrayList一样直接定位到index位置的元素，链表最差要遍历半个链表的元素才能查询到元素，因为链表无法从链表中间直接访问，必须在头或者尾部开始，这就是链表查询比arrayList慢的原因了。