LinkedList源代码阅读

简单介绍LinkedList

LinkedList主要适用于数据频繁添加操作，读多写少的情况。并且是双向列表，由若干个Node对象组成。对比ArrayList它不存在扩容，因为是采用链表结构，每次添加元素都会添加新的Node节点并进行分配空间。

继承实现和接口实现

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

从上面源代码可以看出LinkedList继承了 AbstractSequentialList（顺序存储结构）。

实现接口有：

List接口：使得该实现类有序并且可以重复；

Deque接口：双端队列的实现；

Cloneable：实现这个接口可以使用clone()方法；

Serializable：可以序列化。

LinkedList的成员变量：

transient int size = 0; //集合元素个数

transient Node<E> first;//双向链表的头节点

transient Node<E> last;//尾节点

LinkedList有两个构造方法，一个用于构造空的链表；

public LinkedList() {
    }

另一个用已经有的集合创建链表（调用addAll方法将集合中的元素添加到链表中）。

public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

基本常用方法

boolean add(E e)---添加新元素至链表尾部

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

void addFirst(E e)---添加新元素至链表头部

public void addFirst(E e) {
        linkFirst(e);
    }

void addLast(E e)---添加新元素至链表尾部

public void addLast(E e) {
        linkLast(e);
    }

E get(int index)---遍历列表查找指定位置的元素

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

E getFirst()---获取链表中的头元素

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

E getLast()---获取链表中的尾元素

 public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

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

删除元素：

E remove()---删除列表中的头元素

public E remove() {
        return removeFirst();
    }
 

boolean remove(Object o)---删除指定内容的元素

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

E remove(int index)---删除指定位置的元素

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

E removeFirst()---删除链表中的头元素

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

E removeLast()---删除链表中的尾元素

public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

T[] toArray(T[] a)---将链表转换成数组

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