LinkedList源码学习

1.node

每个node，都包含前后两个，也被前后两个包含。（即 双向链表结构）

  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 ;

        }

    }

2.构造（new）--不像arraylist，没做什么

    public LinkedList() {

    }

    public LinkedList(Collection<? extends E> c ) {

        this ();

        addAll( c );

    }

3.size()

  public int size () {

        return size ;

    }

4.add()

当add第一个的时候，会把其当成first。

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

    }

5.add(index,element) //从这个源码上来看，如果要在中间新增一个，要先找到当前node，查找起来不必arrylist快

   public void add ( int index , E element ) {

        checkPositionIndex( index );

        if ( index == size )

            linkLast( element );

        else

            linkBefore( element , node( index ));

    }

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

    }

    Node<E> node ( int index ) {

        // assert isElementIndex(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 ;

        }

    }

6.remove(index)

    public E remove( int index ) {

        checkElementIndex( index );

        return unlink(node( index ));

    }

    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 ;

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

    }

7.get/set

    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 ;

    }

8.indexOf/contains

  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 boolean contains (Object o ) {

        return indexOf( o ) != -1;

    }

总结

LinkedList是基于双端链表的List，其内部的实现源于对链表的操作，所以适用于频繁增加、删除的情况；该类不是线程安全的；另外，由于LinkedList实现了Queue接口，所以LinkedList不止有队列的接口，还有栈的接口，可以使用LinkedList作为队列和栈的实现。