LinkedList类注释翻译、源码分析

一、类注释翻译

 * Doubly -linked list implementation of the {@code List} and {@code Deque} * interfaces.  Implements all optional list operations, and permits all * elements (including {@code null}).

使用“双向链表”来实现List与Deque接口。 实现了所有List接口中的方法，并且允许存放所有元素，包括Null。

* <p>All of the operations perform as could be expected for a doubly- linked * list.  Operations that index into the list will traverse the list from * the beginning or the end, whichever is closer to the specified index.

所有的操作都可通过双向链表完成。通过从开头或者结尾遍历集合，去接近要操作的那个元素。

 * <p><strong>Note that this implementation is not synchronized.</strong> * If multiple threads access a linked list concurrently, and at least * one of the threads modifies the list structurally, it <i> must</i> be * synchronized externally.  (A structural modification is any operation * that adds or deletes one or more elements; merely setting the value of * an element is not a structural modification.)  This is typically * accomplished by synchronizing on some object that naturally * encapsulates the list. * * If no such object exists, the list should be "wrapped" using the * {@link Collections#synchronizedList Collections.synchronizedList} * method.  This is best done at creation time, to prevent accidental * unsynchronized access to the list: <pre> *   List list = Collections.synchronizedList(new LinkedList(...));</pre> * * <p>The iterators returned by this class's {@code iterator} and * {@code listIterator} methods are <i> fail- fast </i>: if the list is * structurally modified at any time after the iterator is created, in * any way except through the Iterator's own {@code remove} or * {@code add} methods, the iterator will throw a {@link * ConcurrentModificationException} .  Thus, in the face of concurrent * modification, the iterator fails quickly and cleanly, rather than * risking arbitrary, non - deterministic behavior at an undetermined * time in the future. * * <p>Note that the fail - fast behavior of an iterator cannot be guaranteed * as it is, generally speaking, impossible to make any hard guarantees in the * presence of unsynchronized concurrent modification.  Fail- fast iterators * throw {@code ConcurrentModificationException} on a best- effort basis. * Therefore, it would be wrong to write a program that depended on this * exception for its correctness:   <i> the fail- fast behavior of iterators * should be used only to detect bugs. </i>

这几段的翻译与ArrayList相似，请参考：http://blog.csdn.net/disiwei1012/article/details/73947173

二、自己动手实现双向链表

1.定义node节点类
2.实现基本方法

package com.demo4;public class DoubleLinkList {      int length;      private Node header;      private Node tail;      public DoubleLinkList() {           length = 0;           header = null ;           tail = null ;     }      /**      * 打印链表所有元素      */      public void printAll(){          Node currentNode = header ;           while (currentNode != null){              System. out .println(currentNode .obj );               currentNode = currentNode .next ;          }     }      /**      * 删除指定位置元素      * @param index      */      public void removeByIndex(Integer index ){          checkRangIndex( index);          Node node = this .getNode(index );           if (node .prev == null){               header = node. next;               header. prev = null ;          } else if (node .next == null){               tail = node. prev;               tail. next = null ;          } else {              Node preNode = node. prev;              Node nextNode = node. next;               preNode. next = nextNode;               nextNode. prev = preNode;          }           length--;           node = null ;//等待GC回收     }      /**      * 尾插法插入元素      * @param obj      */      public void addTail(Object obj ){           this .addTailByIndex(obj , null);     }      /**      * 头插法插入元素      * @param obj      */      public void addHeader(Object obj ){           this .addHeaderByIndex(obj , null);     }      /**      * 尾插法插入元素，指定位置      * @param obj      * @param index 指定具体插入位置      */      public void addTailByIndex(Object obj ,Integer index ){           if (index == null){               if (header == null){                   createHeader( new Node(null , null, obj));              } else {                   Node node = new Node(tail , null, obj);                    tail. next = node;                    tail = node;                    length++;              }          } else {              checkRangIndex( index);              Node node = this .getNode(index );               node. next = null ;               node. prev = tail;               tail. next = node;               tail = node;               length++;          }     }      /**      * 头插法插入元素,指定位置      * @param obj      * @param index 指定具体插入位置      */      public void addHeaderByIndex(Object obj ,Integer index ){           if (index == null){               if (header == null){                   createHeader( new Node(null , null, obj));              } else {                   Node node = new Node(null ,header ,obj );                    header. prev = node;                    header = node;                    length++;              }          } else {              checkRangIndex( index);              Node node = this .getNode(index );               node. next = header;               node. prev = null ;               header. prev = node;               header = node;               length++;          }     }      /**      * 根据索引获取节点，如果索引在链表的前半部分，则从头节点开始      * 如果索引在链表的后半部分，则从尾节点开始      * @param index      * @return      */      public Node getNode( int index ){          checkRangIndex( index);          Node currentNode = null ;           if (index < length /2){               currentNode = header ;               for (int i = 0;i <index ;i ++){                    currentNode = currentNode .next ;              }          } else {               currentNode = tail ;               for (int i =length -1;i >index ;i --){                    currentNode = currentNode .prev ;              }          }           return currentNode ;     }      /**      * 判断索引地址是否合法      * @param index      */      public void checkRangIndex( int index){           if (index < 0 || index > length-1){               throw new RuntimeException( "索引地址不合法！" );          }     }      /**      * 链表无节时创建头结点，header和tail指向统一节点      * @param node      */      public void createHeader(Node node ){           header = node;           tail = header;           length++;     }      private static class Node{          Node prev;          Node next;          Object obj;           public Node(Node prev ,Node next ,Object obj ) {               this .prev = prev ;               this .next = next ;               this .obj = obj ;          }     }}

三、源码分析

1.我们来看下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 ;        }    }

LinkedList继承关系如下：

LinkedList继承抽象类AbstractSequentialList，我们知道抽象类可以选择实现接口中的方法，也可以不实现接口中的方法，
LinkedList只需实现AbstractSequentialList中未实现的方法、Deque接口中规定的方法、List接口中规定的方法就好了。

public class LinkedList<E>    extends AbstractSequentialList<E>    implements List<E>, Deque<E>, Cloneable, java.io.Serializable{    //存储元素个数，即链表节点的个数    transient int size = 0;    /**     * 头节点     * 满足这两个条件     * 1.(first == null && last == null) 2.(first.prev == null && first.item != null)     */    transient Node<E> first;    /**     * 尾节点     * 满足这两个条件     * 1. (first == null && last == null) 2.(last.next == null && last.item != null)     */    transient Node<E> last;    /**     * 空构造函数     */    public LinkedList() {    }    /**     * 构造一个LinkedList，并将集合c中的元素全部放入     *     * @param   c the collection whose elements are to be placed into this list     * @throws NullPointerException if the specified collection is null     */    public LinkedList(Collection<? extends E> c ) {        this ();        addAll( c);    }    /**     * 头插法插入元素     * 如果该链表没有头结点和尾节点，则将该节点为头尾节点，     * 如果已经有头结点，则插入头结点前方     */    private void linkFirst(E e ) {        final Node<E> f = first ;        final Node<E> newNode = new Node<>( null, e, f);        first = newNode;        if (f == null)            last = newNode;        else            f. prev = newNode;        //元素个数+1        size++;        //修改次数+1        modCount++;    }    /**     * 尾插法插入元素     * 如果该链表没有头结点和尾节点，则将该节点为头尾节点，     * 如果已经有尾结点，则插入尾节点的后方     */    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;        //元素个数+1        size++;        //修改次数+1        modCount++;    }    /**     * 在节点succ前插入节点，succ不能为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;        //如果succ无前节点，succ默认为头结点        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 ; //GC回收        //首节点的后一个节点为新的首节点        first = next;        if (next == null)            last = null ;        else            next. prev = null ;        //元素个数-1        size--;        //修改次数+1        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        //尾节点的prev节点作为新的尾节点        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 ;        //x的下一个节点        final Node<E> next = x .next ;        //x的前一个节点        final Node<E> prev = x .prev ;        //如果无前节点，则x为头节点        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 ;    }    /**     * 返回头节点中保存的数据，如果头节点为null,则抛出NoSuchElementException     * @return the first element in this list     * @throws NoSuchElementException if this list is empty     */    public E getFirst() {        final Node<E> f = first ;        if (f == null)            throw new NoSuchElementException();        return f .item ;    }    /**     * 返回尾节点中保存的数据，如果尾节点为null,则抛出NoSuchElementException     *     * @return the last element in this list     * @throws NoSuchElementException if this list is empty     */    public E getLast() {        final Node<E> l = last ;        if (l == null)            throw new NoSuchElementException();        return l .item ;    }    /**     * 移除头节点，并返回头节点     * @return the first element from this list     * @throws NoSuchElementException if this list is empty     */    public E removeFirst() {        final Node<E> f = first ;        if (f == null)            throw new NoSuchElementException();        return unlinkFirst(f );    }    /**     * 移除尾节点，并返回尾节点     *     * @return the last element from this list     * @throws NoSuchElementException if this list is empty     */    public E removeLast() {        final Node<E> l = last ;        if (l == null)            throw new NoSuchElementException();        return unlinkLast(l );    }    /**     * 头插法插入元素     *     * @param e the element to add     */    public void addFirst(E e ) {        linkFirst( e);    }    /**     * 尾插法插入元素     *     * @param e the element to add     */    public void addLast(E e ) {        linkLast( e);    }    /**     * 判断集合中是否至少有一个节点的数据等于o     *     * @param o element whose presence in this list is to be tested     * @return {@code true} if this list contains the specified element     */    public boolean contains(Object o ) {        return indexOf(o ) != -1;    }    /**     * 返回存储节点的个数     *     * @return the number of elements in this list     */    public int size() {        return size ;    }    /**     * 尾插法插入元素     */    public boolean add(E e ) {        linkLast( e);        return true ;    }    /**     * 移除集合中第一个出现的节点中的数据等于o的节点，如果集合中不包含该元素，则什么都不做     * 如果o为null,则删除第一个数据为null的节点     */    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 ;    }    /*     * 将集合c中的元素全部加到链表的尾部     */    public boolean addAll(Collection<? extends E> c) {        return addAll(size , c );    }    /**     * 将集合c插入到双向链表中，插入的位置是index之后     */    public boolean addAll(int index , Collection<? extends E> c ) {        checkPositionIndex( index);//检测index是否>=0或者<length        Object[] a = c.toArray();        //新加入节点个数        int numNew = a .length ;        if (numNew == 0)//如果没有节点要插入返回false            return false ;        //如果index等于size,则相当于插入尾部        Node<E> pred, succ;        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                pred. next = newNode;            pred = newNode;        }        if (succ == null) {            last = pred;        } else {            pred. next = succ;            succ. prev = pred;        }        size += numNew;        modCount++;        return true ;    }    /**     * 移除集合中全部节点，相当于清空集合，为了确保被GC回收，清空引用     * The list will be empty after this call returns.     */    public void clear() {        // Clearing all of the links between nodes is "unnecessary", but:        // - helps a generational GC if the discarded nodes inhabit        //   more than one generation        // - is sure to free memory even if there is a reachable Iterator        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++;    }    // Positional Access Operations    /**     * 返回指定节点的数据     */    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 ));    }    /**     * Tells if the argument is the index of an existing element.     */    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 ));    }    /**     * 返回指定位置的节点，和我写的差不多     */    Node<E> node( int index ) {        // 若index < 双向链表长度的1/2,则从前先后查找;           // 否则，从后向前查找。         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 ;        }    }    // Search Operations    /**     * 查询对象o在集合中的位置     *  如果对象o为null,返回第一个节点数据为null的节点的位置，     * 否则，返回第一个一个匹配节点的位置。如果未找到，则返回-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;    }    /**     * 查询对象o在集合中的位置     * 如果对象o为null,返回最后一个节点数据为null的节点的位置，     * 否则，返回最后一个匹配节点的位置。如果未找到，则返回-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;    }    // Queue operations.实现队列接口中的方法    /**     * 返回头节点的数据，如果节点为null，则返回null     * @return the head of this list, or {@code null} if this list is empty     * @since 1.5     */    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();    }    /**     * 在尾部增加一个元素e     */    public boolean offer(E e ) {        return add(e );    }    // Deque operations    /**     * 在头部增加一个元素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 ;    }    /**     * 在抽象类AbstractSequentialList中唯一没有实现的方法     * 返回该集合ListIterator迭代器     */    public ListIterator<E> listIterator( int index ) {        checkPositionIndex( index);        return new ListItr( index);    }    private class ListItr implements ListIterator<E> {        private Node<E> lastReturned = null;//最后一个返回的节点，也就是当前持有的节点        private Node<E> next ;//当前持有节点的下一个节点        private int nextIndex ;//当前持有节点的下一个节点位置        private int expectedModCount = modCount ;//实现fast-fail        ListItr( int index ) {            next = ( index == size) ? null : node(index );            nextIndex = index ;        }        //根据nextIndex是否等于size，判断时候是否还有下一个节点        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 ++;        }        //替换当前持有节点的值为e        public void set(E e ) {            if (lastReturned == null)                throw new IllegalStateException();            checkForComodification();            lastReturned .item = e ;        }        //在当前持有节点后插入节点e        public void add(E e ) {            checkForComodification();            lastReturned = null ;            if (next == null)                linkLast( e);            else                linkBefore( e, next);            nextIndex ++;            expectedModCount ++;        }        final void checkForComodification() {//fast-fail具体时间            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.previou     * 从后遍历集合，通过ListItr     */    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();        }    }    /**      *浅拷贝集合，不拷贝元素，自拷贝引用     * @return a shallow copy of this {@code LinkedList} instance     */    public Object clone() {        LinkedList<E> clone = superClone();        // Put clone into "virgin" state        clone. first = clone. last = null ;        clone. size = 0;        clone. modCount = 0;        // Initialize clone with our elements        for (Node<E> x = first ; x != null; x = x. next)            clone.add( x. item);        return clone ;    }    /**     * 返回一个包含该集合所有元素的集合，为了保证集合数组的安全，需要构建一个新数组     * <p> This method acts as bridge between array -based and collection- based     * APIs.     *     * @return an array containing all of the elements in this list     *         in proper sequence     */    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 ;    }    /**     * 给一个数组a,返回一个数组（数组元素按照集合从前往后的顺序排列），该数组包含了集合中的所有元素     * 若数组a的长度不足以装入所有的集合元素，则使用Array.newInstance()这一方法创建一个size大小，     * 元素类型为数组a的元素类型的数组，并将该数组赋值给a     */    @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 ;    }}