跟踪LinkedList源码，通过分析双向链表实现原理，自定义一个双向链表

1.LinkedList实现的基本原理

LinkedList是一个双向链表，它主要有两个表示头尾节点的成员变量first  、last，因其有头尾两个节点，所以从头或从尾操作数据都非常容易快捷。LinkedList通过内部类Node来保存元素 ,一个Node对象表示链表的一个节点，有多少个元素就需要多少个Node节点。如果要添加元素，则新建一个Node节点，保存这个元素，同时指定其前驱节点和后继节点的引用。若要删除一个元素，则将取消此元素对应的Node节点在链表中的前驱后继关系。

2.ListedList实现的关键 -——静态内部类Node

Node类有3个成员变量：

 1）表示当前节点保存的元素item ，

 2）表示后继节点的引用next

 3)表示前驱节点的引用 prev

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

 Node类有这3个成员能够很清楚的表示自己的逻辑结构。首先它能确定自己的位置，属性prev 、next分别指定了前驱、后继节点分别是谁，指明了当前节点在链表结构中的位置；另外成员变量item明确了当前节点要保存的元素。

3.ListedList的成员变量

其成员变量主要是表示链表头 尾节点的两个成员变量：头节点first 、  尾节点last。

因为有头尾两个节点，可以很方便地从头部或从尾部这两个方向进行逻辑操作。

只用一个头节点可实现单向链表，它的效率不高，因为只能从单向从头到尾遍历，不能根据实际情况选择更优的遍历方向。

    // 链表的所含元素个数
    transient int size = 0;

    // 链表的头节点
    transient Node<E> first;
    // 链表的尾节点
    transient Node<E> last;
    /*
     * 此属性在本类中没有，此属性是从父类AbstractSequentialList中继承而来
     * 链表结构被修改的次数，防止在迭代遍历过程中，修改链表结构
     */
    protected    int modCount = 0;

4 .其构造方法

构造方法有两个，一个默认构造方法，将初始化一个空链表；另一个带单参数的构造方法，将初始化后，此链表将包含集合参数c的所有元素

    public LinkedList() { } //头尾节点都是null的空链表

    //初始化后，包含集合c所有元素的链表
    public LinkedList(Collection<? extends E> c) { 
        this();
        addAll(c);//添加集合c所有元素
    }

5.其常用的API

1). public boolean add(E e)   在尾部添加一个元素

此方法去调用了一个对链表尾部连接新元素的方法linkLast(E)

    public boolean add(E e) {
        linkLast(e);//在尾部链接一个新元素
        return true;
    }

 此时去看看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++;//添加一个元素，链表结构被修改一次，modCount自加一
    }

2）public void add(int index, E element)  在指定下标处添加元素

    此方法有两个分支，若插入的下标位置等于链表元素个数，则可直接在链表尾部添加要插入的元素；而其它一般情况则调用linkBefore（E，Node)方法，在指定某节点之前插入指定元素。

而linkBefore(E，Node)的方法参数又调用了Node<E>  node(int)方法。

    public void add(int index, E element) {
        checkPositionIndex(index); //检查下标是否合法

        if (index == size)  //插入的位置index=size即可直接在链表尾部添加元素
            linkLast(element);
        else
            //在指定的节点之前插入元素
            linkBefore(element, node(index));
    }

先来看看node(int)方法是如何根据下标查找到下标对应的Node节点

　　------- node(int)方法中有两个分支，根据index是否小于size的一半作为进入不同分支的条件。此分支条件是用来确定待查找的节点与头/尾节点的距离远近，若待查找的节点和头节点较近，就从头节点开始查找;若待查找的节点与尾节点较近，则从尾节点开始遍历查找。这主要是从遍历效率角度考虑的。

    Node<E> node(int index) {
        //index作为循环遍历停止的条件
        if (index < (size >> 1)) { // 如果index小于size的一半，则从头部开始向后查找
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next; //将当前节点的后继节点赋值给当前节点
            return x;
        } else {     // 如果index大于size的一半，则从尾部开始向前查找
            Node<E> x = last;
            for (int i = size - 1; i > index; i--) 
                x = x.prev;//将当前节点的前驱节点赋值给当前节点
            return x;
        }
    }

最后来看linkBefore（E，Node)如何在指定的节点前添加指定的元素

　　-------其中也对插入位置的进行了判断，如果是在头部插入节点，则需要将头节点的引用更新为待插入节点。

    void linkBefore(E e, Node<E> succ) {
         //插入点节点succ的前驱节点pred
        final Node<E> pred = succ.prev;
        /*
         * 待插入的节点，
         * 此节点将取代插入点节点succ，插入点succ将后移一位
         * 此节点的前驱是插入点节点的前驱节点pred，其后继节点就是插入点节点succ
         */
        final Node<E> newNode = new Node<>(pred, e, succ);
        //插入点节点的前驱是待插入节点
        succ.prev = newNode;
        
        if (pred == null)
            /*
             * 插入点节点的前驱节点pred为为空，表明此时在头部直接插入节点
             * 那么链表更新后，当前的待插入节点就是头节点
             */
            first = newNode;
        else
            /*
             * 插入点节点的前驱节点pred的后继节点是待插入节点
             */
            pred.next = newNode;
        size++;
        modCount++;
    }

3） public E remove(int index)   移除指定位置的元素

 先利用node(int)方法，根据下标查找到对应的Node节点，再调用unlink(Node)方法,取消指定节点在链表中的链接关系。

    public E remove(int index) {
        checkElementIndex(index);//检查下标是否合法
        /*
         * 利用node(int)方法，根据下标查找到对应的Node节点
         * 再调用unlink(Node)方法,取消指定节点在链表中的链接关系
         */
        return unlink(node(index)); 
    }

 node(int)方法已经在之前已经分析过了，这里主要来看unlink(Node)方法的实现 

　　 ------unlink(Node）方法比较复杂，但是将思路理清楚，也就不难理解了。

           (1)因为待移除节点x将被删除，x的前驱prev和x的后继next都将不再依赖x这个中间连接者，所以要将前驱节点prev与后继节点next直接链接起来。LinkedList是双向链表，每个节点都要双向（前后）维护链接关系，即同时维护前驱与后继。那么prev、next两者都要更新链接关系，链表更新后prev的后继节点是next,即prev.next=next, 而next的前前驱节点又是prev,即next.prev=prev 。

           (2)另外还要考虑待移除节点x是头节点或尾节点这种特殊情况（first=next或last=prev）。

           (3)因为待移除节点x不会再被使用了，最后还要将待移除节点x的各个属性赋为null,便于GC回收内存资源（x.item=null ;x.prev=null;x.next=null）。

    E unlink(Node<E> x) {
        //保存待移除节点储存的元素，最后要返回这个被移除的元素
        final E element = x.item;
        //待移除节点的后继节点
        final Node<E> next = x.next;
        //待移除节点的前驱节点
        final Node<E> prev = x.prev;

        /**
         * 维护待移除节点的前节点驱prev的链接关系
         */
        if (prev == null) {
            /*
             * 待移除节点的前驱prev为空，表明待移除节点是头节点
             * 当待移除节点是头节点时，移除元素更新后，待移除节点的后继节点next就是链表更新后的头节点
             * 此时待移除节点的前驱节点本来就为空，不用再去赋为空值
             */
            first = next;
        } else {
            /* 在其他一般情况下（非头节点），更新后
             * 待移除节点的前驱节点prev的后继节点 就是待移除节点的后继节点next
             * 将待移除节点x的属性prev赋为空，便于最后的垃圾回收
             */
            prev.next = next;
            x.prev = null;
        }

        
        /*
         * 维护待移除节点的后继节点的链接关系
         */
        if (next == null) {
            /*
             * 待移除节点的后继next为空，表明待移除节点是尾节点
             * 当待移除节点是尾节点，移除元素更新后，待移除节点的前驱节点prev就是链表更新后的尾节点
             * 此时待移除节点的后继节点本来就为空，不用再去赋为空值
             */
            last = prev;
        } else {
            /* 在其他一般情况下（非尾节点），移除更新后
             * 待移除节点的后继节点next的前驱节点 就是的待移除节点的前驱节点prev
             * 将待移除节点x的属性next赋为空，便于最后的垃圾回收
             */
            next.prev = prev;
            x.next = null;
        }

        x.item = null; //将待移除节点储存的元素引用赋空
        size--;
        modCount++;//链表结构被修改，modCount自加
        return element;//返回被移除元素
    }

4） public E remove(Object o)  根据元素的引用移除元素

根据元素是否为空进入不同的分支。从头元素开始向后遍历，若链表中的一个元素与o相等，则调用unlink(Node)方法移除当前节点，退出循环并返回true；若遍历了所有元素，没有任何一个元素与o相等，则返回false，移除指定元素失败。

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

5）public E set(int index, E element)  替换指定下标对应的元素

   （1）找到下标index对应的节点

   （2）保存index下标位置的原元素值

   （3) 将节点的item属性更新为element

    public E set(int index, E element) {
        checkElementIndex(index);//检查下标
        Node<E> x = node(index); //查找下标index对应的节点
        E oldVal = x.item; //保存原值
        x.item = element;//将下标index对应节点所保存的元素值更新
        return oldVal;
    }

6）public  E get(int index)  获取指定下标对应的元素   

       找到下标index对应的节点，返回此节点的item属性。

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

  

7)  public int indexOf(Object o)  根据元素值确定其第一次出现的位置下标

从头节点开始向后遍历，若找到这个元素则退出循环并返回当前遍历的下标，若不存在此元素返回-1.

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

8)  public int lastIndexOf(Object o)  根据元素值确定其最后一次出现的位置下标

      与“public int indexOf(Object o)”的实现原理基本一致，只有遍历的方向不同而已，此方法是从尾节点向前遍历

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

9）public void clear()  清空所有元素

    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;//不含任何元素，size设为0
        modCount++;
    }

 10)  public boolean addAll(int index, Collection<? extends E> c)  在指定下标处插入所有集合元素

    此方法也对一些特殊情况做了判断分支处理，如在链表的尾部添加元素，或是在链表的头部添加元素等。

    public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);//检查下标
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0) //集合c没有任何元素，不用添加任何一个元素，直接返回false。
            return false;
        //pred表示插入点原节点的前驱节点， succ表示插入点的原节点，
        Node<E> pred, succ; 
        if (index == size) {
            /*
             * index=size表明在链表的尾部批量添加元素
             * 前驱pred为尾节点
             * 插入点的原节点succ不存在,则为null
             */
            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
                //非头部添加节点
                pred.next = newNode;
            //当前新添加节点作为下次遍历时新添加节点的前驱
            pred = newNode;
        }
        
        /**
         * 维护添加最后一个元素时的链接关系
         */
        if (succ == null) {
             /*
              * 在尾部添加时，最后添加的那个元素即为尾节点
              */
            last = pred;
        } else {
            /*
             * 非尾部添加时
             */
            pred.next = succ;
            succ.prev = pred;
        }

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

 6.总结源码经验，仿写双向链表

 一个集合的基本功能是增删改查，总结一下这些功能的大致思路：

1）”增“元素： 可以在链表的尾部增加元素或在链表的中部插入元素。在尾部添加元素需要维护原尾部节点和新添加节点的相互链接关系；而在中部插入新元素需要维护新插入节点、插入点原节点、插入入节点前驱节点 这三个节点间的相互链接关系。可以统一起来看，"增"元素都是插入元素，需要维护新插入节点、新插入节点的前/后节点间的相互链接关系（在尾部添加元素时，其后继节点为空而已）。

2）“删”元素：维护待删节点的前后节点的相互链接关系，即将前后节点直接链接起来，另外还要将待删节点的各属性赋空（利于垃圾回收）。同时得考虑特殊情况下——在头部或尾部删除节点，此时还要更新头节点或尾节点的引用。

3）“改”元素：先根据索引或元素值找到对应的Node节点，再重设该节点的item属性。

4）“查”元素：根据索引，循环遍历找到对应的Node节点，获取该节点的item属性。

和LinkedList相似的双向链表：

package collection;

import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;

public class LinkList<E> implements Iterable<E>, List<E> {
    // 链表的所含元素个数
    private int size = 0;
    // 链表的头节点
    private Node<E> head = null;
    // 链表的尾节点
    private Node<E> tail = null;
    /*
     * 链表结构被修改的次数，防止在迭代遍历过程中，修改链表结构
     */
    int modCount = 0;

    /**
     * 添加一个元素
     * 
     * @param e
     * @return
     */
    public boolean add(E e) {
        return linkTail(e);
    }

    /**
     * 在链表尾部新链接一个元素
     * 
     * @param e
     * @return
     */
    private boolean linkTail(E e) {
        final Node<E> oldTail = tail;

        final Node<E> newNode = new Node<>(oldTail, e, null);
        tail = newNode;
        if (oldTail == null)
            head = newNode;
        else {
            oldTail.next = newNode;
        }

        modCount++;
        size++;
        return true;
    }

    /**
     * 移除指定下标处的元素
     * 
     * @param index
     * @return
     */
    public E remove(int index) {
        checkElementIndex(index);
        Node<E> nodeRemove = fastNodeAt(index);// 快速查找到指定下标对应的节点
        return unlink(nodeRemove); // 取消这个节点在链表结构中链接
    }

    /**
     * 根据下标快速查找节点
     */
    private Node<E> fastNodeAt(int index) {
        if (index < size >> 1) {// 如果index小于size的一半，则从头部开始查找
            Node<E> current = head;

            for (int i = 0; i < index; i++)
                current = current.next;
            return current;

        } else {// 如果index大于size的一半，则从尾部开始查找
            Node<E> current = tail;
            for (int i = size - 1; i > index; i--)
                current = current.prev;
            return current;

        }
    }

    /**
     * 取消指定节点在链表结构中的链接
     */
    private E unlink(Node<E> node) {

        Node<E> prev = node.prev;
        Node<E> next = node.next;
        E oldData = node.data;

        /*
         * 维护被移除节点的前驱节点的链接关系
         */
        if (prev == null) {
            /**
             * 当被移除节点是头节点时，更新后的头节点就是被移除节点的下一节点
             *  此时被移除节点的前节点本来就为空，不用再去赋为空值
             */
            head = next;
        } else {
            prev.next = next;// 更新后，被移除节点的前节点对应的 后节点是 被移除节点的后节点
            // 被移除节点的前节点赋空，若不赋空则一直存在对前置节点的引用，可能出现内存泄漏
            node.prev = null;
        }
        /*
         * 维护被移除节点的后继节点的链接关系
         */
        if (next == null) {
            /**
             * 当被移除节点是尾节点时，更新后的尾节点就是被移除节点的前驱节点 
             * 此时被移除节点的后继节点本来就为空，不用再去赋为空值
             */
            tail = prev;
        } else {
            // 更新后，被移除节点的后继接节点对应的前驱结点 就被移除节点的前驱结点
            next.prev = prev;
            node.next = null;
        }
        node.data = null;
        // node=null;
        size--;
        modCount++;
        return oldData;
    }

    /**
     * 更新指定下标处的元素，
     * 
     * @param index
     * @param e
     * @return 原元素值
     */
    public E set(int index, E e) {
        checkElementIndex(index);// 快速查找到指定下标对应的节点
        Node<E> node = fastNodeAt(index);
        E oldData = node.data; // 保存老值
        node.data = e;
        return oldData;
    }

    /**
     * 获取指定下标的元素
     * 
     * @param index
     * @return
     */
    public E get(int index) {
        checkElementIndex(index);
        return fastNodeAt(index).data;
    }

    /**
     * 指定元素第一次出现的下标位置
     * 
     * @param obj
     * @return
     */
    public int indexOf(Object obj) {
        if (size == 0)// 不含任何元素，返回-1
            return -1;
        int index = 0;
        E curElement;
        for (Node<E> next = head; next != null; next = next.next) {// 从头节点开始遍历
            curElement = next.data;
            if (curElement == obj || (curElement != null && curElement.equals(obj)))
                // 找到了对应的元素，返回当前下标
                return index;
            index++;
        }
        return -1;// 没找到对应的元素
    }

    public Node<E> nodeOf(Object obj) {
        if (size == 0)
            return null;
        E curElement;
        for (Node<E> next = head; next != null; next = next.next) {// 从头节点开始遍历
            curElement = next.data;
            if (curElement == obj || (curElement != null && curElement.equals(obj))) {
                return next;

            }
        }
        return null;
    }

    /**
     * 返回指定元素最后一次出现的下标位置
     * 
     * @param obj
     * @return
     */
    public int lastIndexOf(Object obj) {
        if (size == 0)// 不含任何元素，返回-1
            return -1;
        E curElement;
        int index = 0;
        for (Node<E> prev = tail; prev != null; prev = prev.prev) {// 从尾节点开始遍历
            curElement = prev.data;
            if (curElement == obj || (curElement != null && curElement.equals(obj)))
                return index;
            index++;
        }
        return -1;
    }

    public boolean remove(Object obj) {
        if (size == 0)// 不含任何元素，false
            return false;
        E curElement;
        for (Node<E> next = head; next != null; next = next.next) {// 从头节点开始遍历
            curElement = next.data;
            if (curElement == obj || (curElement != null && curElement.equals(obj))) {
                unlink(next);
                return true;
            }
        }
        return false;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void add(int index, E e) {

        checkElementPosition(index);
        if (index == size) {
            linkTail(e);
        } else {
            linkBefore(index, e);
        }
    }

    private boolean linkBefore(int index, E e) {
        Node<E> node = fastNodeAt(index);
        Node<E> prev = node.prev;
        Node<E> newNode = new Node<>(prev, e, node);
    
        if (prev == null) {
            head = newNode;

        } else {
            prev.next = newNode;

        }
        node.prev = newNode;
        size++;
        modCount++;
        return true;
    }

//    private Node<E> nodeAt(int index) {
//        Node<E> targetNode = null;
//        if (index < (size >> 1)) {// 如果index小于size的一半，则从头部开始查找这个元素
//            Node<E> next = null;
//            int i = 0;
//            for (Node<E> current = head; current != null;) {
//                if (i == index) {
//                    targetNode = current;
//                    break;
//                }
//                next = current.next;
//                current = next;
//                i++;
//            }
//        } else {
//            Node<E> prev = null;
//            int i = size - 1;
//            for (Node<E> current = tail; current != null;) {
//                if (i == index) {
//                    targetNode = current;
//                    break;
//                }
//                prev = current.prev;
//                current = prev;
//                i--;
//            }
//        }
//        return targetNode;
//    }



    /*
     * 检查元素下标对应的元素是否存在
     * 
     */
    private void checkElementIndex(int index) {
        if (index >= size || index < 0)
            throw new IndexOutOfBoundsException(indexOutRangeMsg(index));

    }

    /*
     * 检查在插入元素时，插入位置是否正确
     * 
     */
    private void checkElementPosition(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(indexOutRangeMsg(index));

    }

    private String indexOutRangeMsg(int index) {
        return " index [" + index + "] ,  size [" + size + "]";
    }

    // 表示节点的静态内部类
    private static class Node<E> {
        // 前一个节点
        private Node<E> prev;
        // 下一个节点
        private Node<E> next;
        // 当前节点存储的数据
        private E data;
    
        public Node(Node<E> prev, E data, Node<E> next) {
            super();
            this.prev = prev;
            this.next = next;
            this.data = data;
        }

    }

    @Override
    public Iterator<E> iterator() {

        return new SimpleIterator();
    }

    private class SimpleIterator implements Iterator<E> {
        private int desireModCount = modCount;// 预期的的修改次数
        private Node<E> nextNode = head;// 下次遍历的节点
        private Node<E> lastRetNode = null;// 最终使用的节点
        private int nextIndex = 0;// 下标

        @Override
        public boolean hasNext() {

            return nextIndex < size;
        }

        @Override
        public E next() {
            checkModCount();
            if (!hasNext())
                throw new NoSuchElementException();
            lastRetNode = nextNode;
            E data = lastRetNode.data;
            nextNode = nextNode.next;
            nextIndex++;
            return data;
        }

        @Override
        public void remove() {
            checkModCount();
            if (lastRetNode == null)
                throw new IllegalStateException("");
            Node<E> lastNode = lastRetNode.next;
            LinkList.this.unlink(lastRetNode);

            if (lastNode == lastRetNode)
                nextNode = lastNode;
            else
                nextIndex--;

            lastRetNode = null;
            desireModCount = modCount;

        }

        /*
         * 校验在迭代过程中，是否使用了非迭代的方式改变了链表结构
         */
        private void checkModCount() {
            if (desireModCount != modCount)
                throw new IllegalStateException("迭代过程中的结构被改变了");
        }
    }

    @Override
    public boolean contains(Object o) {

        return indexOf(o) != -1;
    }

    @Override
    public Object[] toArray() {
        if (size == 0)
            return new Object[] {};
        Object[] objs = new Object[size];
        int i = 0;
        for (Node<E> next = head; next != null; next = next.next) {
            objs[i] = next.data;
            i++;
        }
        return objs;
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            a = (T[]) Array.newInstance(a.getClass().getComponentType(), size);
        int i = 0;
        Object[] result = a;
        for (Node<E> x = head; x != null; x = x.next)
            result[i++] = x.data;

        
        return a;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        if (c == null)
            throw new NullPointerException();

        for (Object o : c) {
            if (indexOf(o) == -1)
                return false;
        }
        return true;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        if (c == null)
            throw new NullPointerException();

        return addAll(size, c);
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        checkElementPosition(index);
        if (c.size() == 0)
            return false;
        Node<E> prev, insertPoint;
        if (index == size) {
            prev = tail;
            insertPoint = null;
        } else {
            insertPoint = fastNodeAt(index);
            prev = insertPoint.prev;
        }

        Object[] elementsAdd = c.toArray();

        for (Object o : elementsAdd) {
            @SuppressWarnings("unchecked")
            E e = (E) o;
            Node<E> newNode = new Node<E>(prev, e, null);
            if (prev == null)
                head = newNode;
            else
                prev.next = newNode;
            prev = newNode;
        }

        if (insertPoint == null)
            tail = prev;
        else {
            prev.next = insertPoint;
            insertPoint.prev = prev;
        }

        size += elementsAdd.length;
        modCount++;
        return true;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        if (c == null)
            throw new NullPointerException();
        boolean removeFlag = false;
        Iterator<E> itor = this.iterator();
        while (itor.hasNext()) {
            if (c.contains(itor.next())) {
                itor.remove();
                removeFlag = true;

            }

        }
        return removeFlag;
    }

    @Override
    public boolean retainAll(Collection<?> c) {

        if (c == null)
            throw new NullPointerException();
        boolean retainFlag = false;
        Iterator<E> itor = this.iterator();
        while (itor.hasNext()) {
            if (!c.contains(itor.next())) {
                itor.remove();
                retainFlag = true;
            }
        }
        return retainFlag;
    }

    @Override
    public void clear() {
        if (size == 0)
            return;
        for (Node<E> curNode = head; curNode != null;) {
            Node<E> nextNode = curNode.next;
            curNode.prev = null;
            curNode.data = null;
            curNode.next = null;
            curNode = nextNode;
        }
        size = 0;
        head = null;
        tail = null;
        modCount++;
    }

    @Override
    public ListIterator<E> listIterator() {
        throw new UnsupportedOperationException();

    }

    @Override
    public ListIterator<E> listIterator(int index) {

        throw new UnsupportedOperationException();
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {

        throw new UnsupportedOperationException();
    }

}