LinkedList简单了解

本文只涉及到两部分内容：

• 简单了解下LinkedList源码(add、get、remove的源码)
• LinkedList数据结构

1. 简单了解下LinkedList源码

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
//先了解一下内部结点类：
    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;
        }
    }

    transient Node<E> first;//头结点
    transient Node<E> last;//尾结点

    public LinkedList() {
    //空构造
    }

    public LinkedList(Collection<? extends E> c) {
        this();//访问空构造
        addAll(c);//添加集合。
    }

//从add方法开始看吧：
    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++;
    }
//插入方法：
    public void add(int index, E element) {
        checkPositionIndex(index);//检查下标

        if (index == size)
            linkLast(element);//插到最后
        else
            linkBefore(element, node(index));//中间插入
    }

    Node<E> node(int 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;
        }
    }

    void linkBefore(E e, Node<E> succ) {
        //新建结点 原index结点向后移动 插入新结点到index 设置
        //index+1的prev指针域和index-1的next指针域。
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;//index+1的prev指针域
        if (pred == null)//是否插入到第一个
            first = newNode;
        else
            pred.next = newNode;//index-1的next指针域
        size++;//结点长度，也就是数据大小
        modCount++;//修改次数
    }


//get方法
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;//上面的二分查找
       //因为是双向链表存储结构，只有知道前一个结点的位置才能知道后一
       //个结点的位置或者知道后一个结点才能知道前一个结点的位置，
       //在随机访问方法中，要查找一个数据，需要从头或者末尾开始
       //查找，数据量越大越耗时。
    }


//remove方法，remove方法较多，原理都一样，看一个就够了：
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

 E unlink(Node<E> x) {
         //相当简单 找到index位置的结点 拿到它们的前后结点
         //重新设置前结点的next指针域和后结点的prev指针域
         //然后清空index数据
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {//是否为头结点
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {//是否是尾结点
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

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

2. LinkedList数据结构

//LinkendList基于双向链表结构。在插入和删除中只需要操作
//index-1,index,index+1结点，时间复杂度不受数据量的影响。
//因为链表存储结构的特性，通过上一个结点的数据才能得到下一个
//结点的数据，所以随机访问方法的时间复杂度受数据量的影响。
//LinkedList为双向链表结构在随机访问上也有一定的优化。