java核心知识之集合详解九（LinkedList源码详解）

什么是链表？

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

单向链表

单向链表是通过每一个结点的指针指向下一个结点从而连接起来的结构，最后一个节点的next指针指向null值。单向链表的构造图如下所示：

单向循环链表

单向循环链表与单向链表类似，但是有一点不同的是单向循环链表的最后一个节点的next指针指向的不是null值，而是指向链表头部节点，这样子就形成了一个链表环。单向循环链表构造图如下所示：

双向链表

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继（next指针）和直接前驱（pre指针），pre指向前一个节点，next指向后一个节点。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。但是第一个节点head的pre指向null，最后一个节点的tail指向null。双向链表的构造图如下所示：

如果上面这幅图不够清楚，那么请看下面这幅图的构造，head结点的pre指针指向null值，而tail结点的next指针指向null值。

双向循环链表

双向循环链表和双向链表的不同在于，head节点的pre指针指向最后一个节点，最后一个节点的next指针指向第一个节点，也形成一个“环”。双向循环链表构造如图所示：

LinkedList集合

LinkedList类是List接口的实现类，但是它的实现方式和ArrayList类的实现方式是完全不同的，ArrayList类的底层是通过一个动态的Object[]数组实现的，ArrayList类支持随机访问，但是它的增加元素和删出元素的速度慢，而LinkedList类的底层是通过链表来实现的，它不支持随机访问，但是删除和插入元素的操作快。LinkedList是一个非线程安全的集合，只适合在单线程的环境下使用。LinkedList类实现了Deque接口、Queue接口，它还是一个队列，可以当成双端队列来使用。

LinkedList的类继承实现图

LinkedList类是List接口，Queue接口，Deque接口的实现类，它同时还继承了AbstractSequentialList的双向链表，所以LinkedList类可以当做是堆栈，队列或是双端队列进行使用。

LinkedList类实现了Serialieable接口，这表明LinkedList类是支持序列化和反序列化的，它能够通过序列化传输。LinkedList类同时还实现了Cloneable接口，覆盖重写了clone()函数，即支持复制克隆操作。

变量定义

public class LinkedList<E> extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
    // 存储链表元素的个数
	 transient int size = 0;
	 // 定义链表的前驱节点
	 transient Node<E> first;
	 // 定义链表的后继节点
	 transient Node<E> last;
}

节点的定义

LinkedList源码中的节点代码，以及头节点、尾节点和存储元素变量， LinkedList类的底层是双向链表，双向链表是由一个一个节点单元连接在一起形成的，每一个节点中包含3个组成部分，上一个节点的内存地址、存储的数据、下一个节点的内存地址。如下所示：Node< E >类是LinkedList类中的静态内部类，表示节点对象，其中 item用于存储数据，next存储下一个节点的内存地址，prev存储上一个节点的内存地址。

// 定义静态内部类，链表节点对象类
private static class Node<E> {
		// 定义泛型变量，LinkedList类每一个节点数据都是使用它存储的。
        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;
        }
    }

构造方法

第一种构造方法： 构造一个空列表。

// 构造一个空的列表
 public LinkedList() {
    }

第二种构造方法： 将一个指定的集合添加到LinkedList中，先完成初始化，在调用添加操作

 // 将一个指定的集合添加到LinkedList中，先完成初始化，在调用添加操作
 public LinkedList(Collection<? extends E> c) {
        this(); // 初始化列表
        addAll(c); // 执行添加集合元素的操作
    }

添加元素

添加元素有四个版本，添加头部元素，添加尾部元素，在指定位置添加元素，将一个集合转变成一个链表。其中addFirst(E e)方法是添加头部元素，因为有头指针指向链表的头部，只需要调整几个相关的引用即可。add(E e)是添加元素到尾部，具体与添加头部元素类似。add(int index, E element)方法是在指定下表处插入元素，需要先通过线性查找找到具体位置，然后修改相关引用完成插入操作。

添加头部元素

	/**
     * 在此列表的开头插入指定元素。
     */
    public void addFirst(E e) {
        linkFirst(e);
    }
    private void linkFirst(E e) {
    	// 将f节点指向头节点
        final Node<E> f = first;
        // 新建一个newNode节点，并以f节点作为后继节点
        final Node<E> newNode = new Node<>(null, e, f);
        // 将头节点指向新创建的节点
        first = newNode;
        // 如果头节点为空
        if (f == null)
        // 将尾节点指向新创建的节点
            last = newNode;
        else
        // 如果头结点不为空，f节点的前驱节点指向新创建的节点
            f.prev = newNode;
        size++;
        modCount++;
    }

如图所示：

添加尾部元素

	// 添加元素进尾部链表中
	public boolean add(E e) {
        linkLast(e);
        return true;
    }
	/**
 	*  将指定元素添加进此链表的尾部。
 	*/
 	public void addLast(E e) {
        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)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

如图所示：

在指定位置添加元素

/**
 * index: 指定位置
 * element: 添加的元素
 */ 
public void add(int index, E element) {
		// 检测index是否越界
        checkPositionIndex(index);
        // 如果添加的位置index等于链表长度，说明在链表的尾部添加元素
        if (index == size)
            linkLast(element);
        else
        // 在查找出index之后的元素插入新的元素
            linkBefore(element, node(index));
    }

如图所示：

添加集合元素

添加集合元素首先是检测当前链表中的长度，然后将集合转换成数组，如果传入的插入位置等于链表长度，那就说明在链表尾部添加元素。否则就是以集合为基础构建一个新的链表。

	public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }
    public boolean addAll(int index, Collection<? extends E> c) {
        // 检测index是否越界
        checkPositionIndex(index);
		// 集合转变数组
        Object[] a = c.toArray();
        int numNew = a.length;
        // 如果长度为零说明集合为空，直接返回false
        if (numNew == 0)
            return false;

        Node<E> pred, succ;
        // 如果index等于链表长度，从链表尾部进行添加元素
        if (index == size) {
            succ = null;
            pred = last;
        } else {
        	// 如果不等于，查找对于位置的节点，然后从这个节点开始插入元素
            succ = node(index);
            pred = succ.prev;
        }
		// 遍历元素并将元素添加进链表里
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            // 如果后继为空，说明链表为空。
            if (pred == null)
            // 头节点指向新创建的节点
                first = newNode;
            else
            // 否则后继节点的next指针指向新创建的节点
                pred.next = newNode;
             // pred节点移动到下一个节点。
            pred = newNode;
        }

        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

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

删除元素

删除元素有四种方法，一种是删除第一个元素removeFirst()，一种是删除最后一个元素removeLast() ，一种是删除指定元素remove(Object o)，一种是删除指定位置的元素remove(int index)。

删除第一个元素

public E removeFirst() {
		// 获取头部指针
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }
     private E unlinkFirst(Node<E> f) {
     // 获取头部存储的元素
        final E element = f.item;
        // next指向链表的头部的下一个节点
        final Node<E> next = f.next;
        // 然后将链表头节点的元素和指针赋值null，有效帮助垃圾回收
        f.item = null;
        f.next = null; // help GC
        // 将头部指针归位
        first = next;
        // 如果链表只有一个元素，那尾部指针也为空
        if (next == null)
            last = null;
        else
        // 如果链表不只有一个元素，那将第二个节点的前驱节点指向null，因为已经删除了头结点了
            next.prev = null;
        // 链表长度减1
        size--;
        modCount++;
        // 返回保存的旧的节点
        return element;
    }

删除最后一个元素

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 = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

删除指定元素

删除指定的元素需要先查找到该元素，如果该元素查找不到，说明不在链表中，那就直接返回false，如果链表为空，那也直接返回false，否则删除成功，则返回true。

public boolean remove(Object o) {
        if (o == null) {
       	// 判断要删除的节点是否为null值，这是一个特殊的案例
            for (Node<E> x = first; x != null; x = x.next) {
            // 使用 == 比较的引用地址
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
         // 使用for循环查找到要删除的元素
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                // equals比较的是值
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

第一种情况： 删除的元素位于头结点

第二种情况：删除的元素位于尾部

第三种情况： 删除的元素的位置链表中间

删除指定位置元素

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

unlink()方法

E unlink(Node<E> x) {
        // 保存要删除的节点
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;
		// 如果要删除的节点是头节点，那就将头节点直接指向下一个节点
        if (prev == null) {
            first = next;
        } else {
        // 如果删的不是头节点，删除节点的上一个节点的next指针指向删除节点的下一个节点
            prev.next = next;
            x.prev = null;
        }
        // 要删除的节点是尾节点
        if (next == null) {
        // last尾节点往前移动
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

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

查找元素

get(index)方法

LinkedList类的get(index)方法的作用是获取到链表中指定位置（index）的元素。首先会调用checkElementIndex(index)方法进行判断index是否越界，不越界，那就从链表中找到指定位置的元素并返回。

// 获取链表中指定位置的元素
public E get(int index) {
		// 检测位置是否越界
        checkElementIndex(index);
        return node(index).item;
    }
// 判断index是否越界，越界则抛出异常
private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
// 传入的index和链表的长度对比
private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }
// 返回指定位置的元素，为了效率问题，
// 如果说指定的位置大于链表长度的一半，那就从链表的尾部进行遍历，
// 否则从链表的头部进行遍历。
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;
        }
    }

getFirst()方法

获取链表的第一个元素，首先获取到链表的头节点，然后判断头结点是否为空，不为空返回节点数据，为空则抛出异常。

 public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

getLast()方法

获取链表的最后一个元素，首先获取到链表的尾节点，然后判断尾结点是否为空，不为空返回节点数据，为空则抛出异常。

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

clear()方法清空链表

为了让GC更快可以回收放置的元素，需要将node之间的引用关系赋空。

	/**
     * 删除列表中所有的元素。调用这个函数后，列表将为空。
     */
    public void clear() {
    	// 清除节点之间的所有"非不要"的链接，如果丢弃的节点超过一代，
    	// 则有助于分代GC垃圾回收。 即使存在可到达的迭代，也肯定会释放内存
        for (Node<E> x = first; x != null; ) {
        	// 遍历每一个节点，将所有的节点的值全部赋值为null值，帮助java虚拟机进行垃圾回收
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }

Queue方法

   	/**
     * 返回头部元素但不删除 
     */
    public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }

    /**
     * 检索但不删除此列表的头部（第一个元素）
     */
    public E element() {
        return getFirst();
    }

    /**
     * 返回头部元素并删除
     */
    public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

    /**
     * 返回并删除头部元素
     */
    public E remove() {
        return removeFirst();
    }

    /**
     * 添加指定元素作为此列表的尾部（最后一个元素）
     */
    public boolean offer(E e) {
        return add(e);
    }

Deque方法

/**
 * 在此列表的前面插入指定的元素。
 */
public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}

/**
 * 在此列表的末尾插入指定的元素。
 */
public boolean offerLast(E e) {
    addLast(e);
    return true;
}

/**
 * 检索但不删除此列表的第一个元素，如果此列表为空，则返回 null。
 */
public E peekFirst() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
 }

/**
 *检索但不删除此列表中的最后一个元素，如果此列表为空，则返回null
 */
public E peekLast() {
    final Node<E> l = last;
    return (l == null) ? null : l.item;
}

/**
 * 检索并删除此列表的第一个元素，如果此列表为空，则返回null。
 */
public E pollFirst() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

/**
 * 检索并删除此列表的最后一个元素，如果此列表为空，则返回 null。
 */
public E pollLast() {
    final Node<E> l = last;
    return (l == null) ? null : unlinkLast(l);
}

/**
 * 将元素推送到此列表表示的堆栈上。换句话说，在这个列表的前面插入元素。
 */
public void push(E e) {
    addFirst(e);
}

/**
 * 从此列表表示的堆栈中弹出一个元素。换句话说，删除并返回此列表的第一个元素。
 */
public E pop() {
    return removeFirst();
}

/**
 * 删除此列表中第一次出现的指定元素（从头到尾遍历列表时）。如果列表不包含该元素，则它不变。
 */
public boolean removeFirstOccurrence(Object o) {
    return remove(o);
}

/**
 * 删除此列表中指定元素的最后一次出现（从头到尾遍历列表时）。如果列表不包含该元素，则它不变。
 */
public boolean removeLastOccurrence(Object o) {
    if (o == null) {
        for (Node<E> x = last; x != null; x = x.prev) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node<E> x = last; x != null; x = x.prev) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

源码解析

public class LinkedList<E>extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
 	 // 保存LinkedList类中已经存放的元素个数
    transient int size = 0;  
 	// 定义头节点
    transient Node<E> first;  
    // 定义尾节点
    transient Node<E> last;   
 
    //构造方法，创建一个空的列表
    public LinkedList() {
    }
 
    //将一个指定的集合元素添加到LinkedList类中，首先完成类的初始化，构造出一个空的列表，然后再调用添加操作将集合元素添加进列表里。
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }
 
    //插入头节点
    private void linkFirst(E e) {
    	// 将头节点赋值给f节点
        final Node<E> f = first;  
        // new 一个新的节点，此节点的data = e , pre = null , next - > f 
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode; //将新创建的节点地址复制给first
        // f == null，表示此时LinkedList为空
        if (f == null)  
         // 将新创建的节点赋值给last
            last = newNode; 
        else
        //否则f.前驱指向newNode
            f.prev = newNode;  
        // 保存的集合元素加1
        size++;
        modCount++;
    }
 
    //插入尾节点
    void linkLast(E e) {
    	// 将last（尾）节点赋值给l节点
        final Node<E> l = last;
        //  创建一个新的节点，节点元素数据是传入的要添加进尾部的数据
        final Node<E> newNode = new Node<>(l, e, null);
        // 尾节点执行新创建的节点
        last = newNode;
        // 如果尾节点为空，说明这个时候的链表为空
        if (l == null)
        // 将头结点指向新创建的节点
            first = newNode;
        else
       	// 如果尾节点不为空，将l节点
            l.next = newNode;
        size++;
        modCount++;
    }
 
    //在succ节点前插入e节点，并修改各个节点之间的前驱后继
    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)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }
 
    //删除头节点
    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)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }
 
    //删除尾节点
    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)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }
 
    //删除指定节点
    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) {
            first = next;   //如果前驱为null, 说明此节点为头节点
        } else {
            prev.next = next;  //前驱结点的后继节点指向当前节点的后继节点
            x.prev = null;     //当前节点的前驱置空
        }
 
        if (next == null) {    //如果当前节点的后继节点为null ,说明此节点为尾节点
            last = prev;
        } else {
            next.prev = prev;  //当前节点的后继节点的前驱指向当前节点的前驱节点
            x.next = null;     //当前节点的后继置空
        }
 
        x.item = null;     //当前节点的元素设置为null ,等待垃圾回收
        size--;
        modCount++;
        return element;
    }
 
    //获取LinkedList中的第一个节点信息
    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }
 
    //获取LinkedList中的最后一个节点信息
    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }
 
    //删除头节点
    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);
    }
 
    //将添加的元素设置为LinkedList的头节点
    public void addFirst(E e) {
        linkFirst(e);
    }
 
    //将添加的元素设置为LinkedList的尾节点
    public void addLast(E e) {
        linkLast(e);
    }
 
    //判断LinkedList是否包含指定的元素
    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }
 
    //返回List中元素的数量
    public int size() {
        return size;
    }
 
    //在LinkedList的尾部添加元素
    public boolean add(E e) {
        linkLast(e);
        return true;
    }
 
    //删除指定的元素
    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;
    }
 
    //将集合中的元素添加到List中
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }
 
    //将集合中的元素全部插入到List中，并从指定的位置开始
    public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);
 
        Object[] a = c.toArray();  //将集合转化为数组
        int numNew = a.length;  //获取集合中元素的数量
        if (numNew == 0)   //集合中没有元素，返回false
            return false;
 
        Node<E> pred, succ;
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            succ = node(index); //获取位置为index的结点元素，并赋值给succ
            pred = succ.prev;
        }
 
        for (Object o : a) {  //遍历数组进行插入操作。修改节点的前驱后继
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }
 
        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }
 
        size += numNew;
        modCount++;
        return true;
    }
 
    //删除List中所有的元素
    public void clear() {
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }
 
 
    //获取指定位置的元素
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
 
    //将节点防止在指定的位置
    public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }
 
    //将节点放置在指定的位置
    public void add(int index, E element) {
        checkPositionIndex(index);
 
        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }
 
    //删除指定位置的元素
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }
 
    //判断索引是否合法
    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }
 
    //判断位置是否合法
    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }
 
    //索引溢出信息
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }
    //检查节点是否合法
    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    //检查位置是否合法
    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
 
    //返回指定位置的节点信息
    //LinkedList无法随机访问，只能通过遍历的方式找到相应的节点
    //为了提高效率，当前位置首先和元素数量的中间位置开始判断，小于中间位置，
    //从头节点开始遍历，大于中间位置从尾节点开始遍历
    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;
        }
    }
 
    //返回第一次出现指定元素的位置
    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++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }
 
    //返回最后一次出现元素的位置
    public int lastIndexOf(Object o) {
        int index = size;
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (x.item == null)
                    return index;
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (o.equals(x.item))
                    return index;
            }
        }
        return -1;
    }
 
    //弹出第一个元素的值
    public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }
 
    //获取第一个元素
    public E element() {
        return getFirst();
    }
 
    //弹出第一元素，并删除
    public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
 
    //删除第一个元素
    public E remove() {
        return removeFirst();
    }
 
    //添加到尾部
    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);
    }
 
    //如队列，添加到头部
    public void push(E e) {
        addFirst(e);
    }
 
    //出队列删除第一个节点
    public E pop() {
        return removeFirst();
    }
 
   //删除指定元素第一次出现的位置
    public boolean removeFirstOccurrence(Object o) {
        return remove(o);
    }
 
    //删除指定元素最后一次出现的位置
    public boolean removeLastOccurrence(Object o) {
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
 
    //遍历方法
    public ListIterator<E> listIterator(int index) {
        checkPositionIndex(index);
        return new ListItr(index);
    }
    //内部类，实现ListIterator接口
    private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned = null;
        private Node<E> next;
        private int nextIndex;
        private int expectedModCount = modCount;
 
        ListItr(int index) {
            // assert isPositionIndex(index);
            next = (index == size) ? null : node(index);
            nextIndex = index;
        }
 
        public boolean hasNext() {
            return nextIndex < size;
        }
 
        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();
 
            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }
 
        public boolean hasPrevious() {
            return nextIndex > 0;
        }
 
        public E previous() {
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();
 
            lastReturned = next = (next == null) ? last : next.prev;
            nextIndex--;
            return lastReturned.item;
        }
 
        public int nextIndex() {
            return nextIndex;
        }
 
        public int previousIndex() {
            return nextIndex - 1;
        }
 
        public void remove() {
            checkForComodification();
            if (lastReturned == null)
                throw new IllegalStateException();
 
            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;
        }
 
        public void set(E e) {
            if (lastReturned == null)
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.item = e;
        }
 
        public void add(E e) {
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }
 
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
    //静态内部类，创建节点
    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;
        }
    }
 
    /**
     * @since 1.6
     */
    public Iterator<E> descendingIterator() {
        return new DescendingIterator();
    }
 
    /**
     * Adapter to provide descending iterators via ListItr.previous
     */
    private class DescendingIterator implements Iterator<E> {
        private final ListItr itr = new ListItr(size());
        public boolean hasNext() {
            return itr.hasPrevious();
        }
        public E next() {
            return itr.previous();
        }
        public void remove() {
            itr.remove();
        }
    }
 
    @SuppressWarnings("unchecked")
    private LinkedList<E> superClone() {
        try {
            return (LinkedList<E>) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }
 
  	// 继承了Cloneable接口，重写了clone()方法，支持复制克隆操作
    public Object clone() {
        LinkedList<E> clone = superClone();
        // Put clone into "virgin" state
        clone.first = clone.last = null;
        clone.size = 0;
        clone.modCount = 0;
 
        // 遍历元素，将元素添加进由克隆后产生的链表中
        for (Node<E> x = first; x != null; x = x.next)
            clone.add(x.item);
 
        return clone;
    }
 
    // 将链表转换成Object数组
    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;
    }
 
    // 将链表转换成泛型数组
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            a = (T[])java.lang.reflect.Array.newInstance(
                                a.getClass().getComponentType(), size);
        int i = 0;
        Object[] result = a;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
 
        if (a.length > size)
            a[size] = null;
 
        return a;
    }
 	// 序列化标记
    private static final long serialVersionUID = 876323262645176354L;
 
    //将对象写入到输出流中
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        // Write out any hidden serialization magic
        s.defaultWriteObject();
 
        // Write out size
        s.writeInt(size);
 
        // Write out all elements in the proper order.
        for (Node<E> x = first; x != null; x = x.next)
            s.writeObject(x.item);
    }
 
    //从输入流中将对象读出
    @SuppressWarnings("unchecked")
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();
 
        // Read in size
        int size = s.readInt();
 
        // Read in all elements in the proper order.
        for (int i = 0; i < size; i++)
            linkLast((E)s.readObject());
    }
}