LinkedList源码学习

本文主要写了关于ArrayList的添加和删除以及容量扩充的源码解析，更多的方法源码解析将在之后更新
http://blog.csdn.net/a1n9n7e/article/details/77619479
LinkedList是基于链表实现的数据结构

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

add() 方法

    /**
     * Pointer to first node. 指向第一个结点
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;
    /**
     * Pointer to last node. 指向最后一个结点
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

    public boolean add(E e) {
            linkLast(e);
            return true;
        }


    /**
     * Links e as last element.
     */
    void linkLast(E e) {
      //获取链表的最后一个节点
        final Node<E> l = last;

        //创建一个结点，该结点的前驱指向原来内部链表的最后一个结点last
        final Node<E> newNode = new Node<>(l, e, null);

        last = newNode;
        if (l == null) // 最后一个结点为空，则将第一个结点设为 当前添加进来的结点
            first = newNode; 
        else            //直接在链表的末尾，添加结点
            l.next = newNode; 
        size++;
        modCount++;
    }

这里可以看出，调用add方法添加元素时，每次都会先获取当前链表的最后一个结点，并将新增元素添加到当前链表尾部。对比ArrayList的add() 方法，明显LinkedList 在进行添加操作时方法的性能和效率有明显优势

删除元素

//删除list的第一个元素  
public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

//删除list的最后一个元素   
 public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

//删除包含指定对象的list结点
public boolean remove(Object o) {
        //对象为空，从头遍历链表，找出链表中对象元素值为空的节点，并删除 unlink(x);
        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;
    }

//根据指针位置unlink(node(index))节点
public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }
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));
    }

从上述源码中可以看出，最终都会调用unlink（Node）这么一个方法

下面看看unlink（）方法的源码，这里主要涉及到的是双向循环链表中结点前后指针的替换更改，读者注意源码中出现的判定条件即可，在次不做赘述。

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

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

    /**
     * Unlinks non-null last node 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;
    }

对比ArrayList

对比LinkedList

ArrayList和LinkedList的大致区别如下:

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

总结：

1．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

2．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

3．LinkedList不支持高效的随机元素访问。

4．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。