LinkedList详解

一.关于 LinkedList 常见内容

　　描述:实现 List<E> 接口;元素可排序,可重复,可为 null ,不是线程安全的.

　　继承以及实现关系:

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

　　描述: List<E> 接口定义了列表的方法和默认实现, AbstractSequentialList<E> 继承自 AbstractList<E> ,在其基础上又添加了迭代查询的实现. Deque<E> 接口表示含有队列、双端队列的API,是队列的一种实现, Cloneable 接口表示可以克隆, Serializable 接口表示可以序列化,用于数据传输

二. LinkedList 的实现原理

　　 LinkedList 是通过链表实现的,每一个元素都存放在一个链表的节点中,对列表的操作就是对链表的操作,由于不支持随机访问,所以 LinkedList 只能通过顺序访问(是链表结构导致的),但由于添加或者删除元素时只是修改相关节点中对应的引用变量,所以单纯的增删操作比数组和 ArrayList 更快

三.定义的属性和节点

　　属性:

    // 大小
    transient int size = 0;
    // 头结点
    transient Node<E> first;
    // 尾节点
    transient Node<E> last;

　　　　大小:表示列表当前存放的元素数量

　　　　头结点:表示列表的第一个节点(引用)

　　　　尾节点:表示列表的最后一个节点(引用)

　　　　由节点的内容可以看出 LinkedList 维护的是一个双向链表

　　节点:

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

　　　　描述:每一个节点中都包含了元素和前后节点的引用变量

三.一些重要的方法

　　1.构造方法

    public LinkedList() {
    }

    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

　　　　描述: LinkedList 在创建是都是空的,没有任何节点

　　2.node

    // 查找指定位置的节点
    Node<E> node(int index) {
        // assert isElementIndex(index);
        // index 近头
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        }
        // index 近尾
        else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

　　　　描述:为了提高效率,node方法在进行节点查找时,会先判断index是近头还是近尾,近头就从头结点开始查找,近尾就从尾节点开始查找;相似的,在进行元素查找时(即indexOf和lastIndexOf方法),也是使用的近头和近尾再查找

　　3.linkFirst

    // e 作为头元素，头插
    private void linkFirst(E e) {
        final Node<E> f = first;
        // 新建一个节点，内容为 e 无前节点，后节点为原来的头节点
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            // 如果原头节点不存在，即为空链表，则头尾节点是同一个节点
            last = newNode;
        else
            // 如果原头节点存在，则将原头节点的前一节点置为新建节点
            f.prev = newNode;
        size++;
        modCount++;
    }

　　　　描述:在列表头添加一个新元素,新元素的节点作为列表的新的头节点,应用有双端队列中头部添加元素,压栈操作

　　4.linkLast

    // e 作为尾节点，尾插
    void linkLast(E e) {
        final Node<E> l = last;
        // 新建一个节点，前一节点为原尾节点，无后一节点
        final Node<E> newNode = new Node<>(l, e, null);
        // 更新尾节点
        last = newNode;
        if (l == null)
            // 若原尾节点为 null ，则为空链表，头尾节点是同一节点
            first = newNode;
        else
            // 否则原尾节点的下一个节点是新的尾节点
            l.next = newNode;
        size++;
        modCount++;
    }

　　　　描述:在列表尾部添加一个元素,应用有想队列(单端)中添加元素

　　5.linkBefore

    // e 元素插入某一元素之前，该元素不为 null
    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)
            // 如果目标节点的原前一节点为 null，则表示该节点为头节点，需将新节点置为头节点
            first = newNode;
        else
            // 否则需将目标节点的原前一节点的下一节点置为新节点
            pred.next = newNode;
        size++;
        modCount++;
    }

　　6.unlink

    // 删除某一不为空的节点
    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) {
            // 前一节点为 null ，则该节点为头节点，将头节点置为其后一节点
            first = next;
        } else {
            // 否则前一节点的后一节点置为该节点的后一节点，该节点的前一节点置为 null
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            // 如果该节点的后一节点为 null ，即该节点为尾节点，则将尾节点置为该节点的前一节点
            last = prev;
        } else {
            // 否则该节点的后一节点的前一节点置为该节点的前一节点，该节点的后一节点置为 nulll
            next.prev = prev;
            x.next = null;
        }

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

　　7.unlinkFirst

    // 头删
    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)
            // 如果没有后一个节点，即只有一个节点，则尾节点也置为 null
            last = null;
        else
            // 否则后一个节点的前一节点置为 null
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

　　　　描述:从列表头部删除一个元素,应用有从队列中取元素,应用有出栈

　　8.unlinkLast

    // 尾删
    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)
            // 如果原尾节点没有前一节点，即只有一个节点，则头节点置为 null
            first = null;
        else
            // 否则原尾结点的前一节点的下一节点置为 null
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

　　　　描述:从列表尾部删除一个元素

　　9.定位方法

    // 已存在的元素的 index
    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    // 迭代或者添加操作的有效位置的 index
    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

五.常用的API

　　1.get

    public E get(int index) {
        checkElementIndex(index);
        // 查询指定位置的节点
        return node(index).item;
    }

　　2.set

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

　　3.indexOf

    public int indexOf(Object o) {
        int index = 0;
        // null 和非 null 的判断方式不一样
        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;
    }

　　　　描述:lastIndexOf也相似,只是开始的位置的尾节点,一次向前查找

　　4.add

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

　　　　描述:add方法是直接调用尾插方法,强制返回true

　　5.remove

    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

　　6.toArray

    public Object[] toArray() {
        Object[] result = new Object[size];
        int i = 0;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
        return result;
    }

　　　　描述:新建一个等长数组,遍历集合挨个放入

　　6.队列中定义的方法如:peek,poll,offer;以及栈定义的方法:push,pop

受限于个人水平,如有错误或者补充望请告知(博客园:xiao_lin_unit)