LinkedList(jdk1.6)

private transient Entry<E> header = new Entry<E>(null, null, null);

定義一個空的Entry物件作為頭結點，Entry是其內部定義的一個內部靜態類，結構如下：

private static class Entry<E> {
    E element;
    Entry<E> next;
    Entry<E> previous;

    Entry(E element, Entry<E> next, Entry<E> previous) {
        this
 
.element = element;
        this.next = next;
        this.previous = previous;
    }
}

建構函式

public LinkedList() {
        header.next = header.previous = header;
    }

即把首結點尾結點都指向頭結點

 public E getFirst() {
    if (size==0)
        throw new NoSuchElementException();

    return header.next.element;
    }
 

獲取元素首節點，如果連結串列中沒有元素，會報NoSuchElementException錯誤。

 public E getLast()  {
    if (size==0)
        throw new NoSuchElementException();

    return header.previous.element;
}

獲取元素尾結點，同樣的，如果連結串列中沒有元素，會報NoSuchElementException錯誤。

public E removeFirst() {
    return remove(header.next);
}

刪除首結點，其內部是通過下面函式實現的

private E remove(Entry<E> e) {
    if (e == header)
        throw new NoSuchElementException();

        E result = e.element;
        e.previous.next = e.next;
        e.next.previous = e.previous;
        e.next = e.previous = null;
        e.element = null;
        size--;
        modCount++;
        return result;
    }

實現原理就是把要刪除結點的前一個結點的下一個節點指向要刪除結點的下一個節點，把要輸出結點的下一個節點的前結點指向要刪除結點的前一個結點，把刪除結點的相關成員置空，並返回刪除的元素值。

public E removeLast() {
    return remove(header.previous);
    }

刪除尾結點，原理如上。

public boolean remove(Object o) {
        if (o==null) {
            for (Entry<E> e = header.next; e != header; e = e.next) {
                if (e.element==null) {
                    remove(e);
                    return true;
                }
            }
        } else {
            for (Entry<E> e = header.next; e != header; e = e.next) {
                if (o.equals(e.element)) {
                    remove(e);
                    return true;
                }
            }
        }
        return false;
    }

刪除結點，遍歷到對應的結點刪除，刪除原理如上。

public E remove(int index) {
        return remove(entry(index));
    }

根索引值獲取對應Entry，刪除原理如上，entry函式的實現在下面會寫。

public void addFirst(E e) {
    addBefore(e, header.next);
}

新增首節點，其內部實現原理如下：

private Entry<E> addBefore(E e, Entry<E> entry) {
        Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
        newEntry.previous.next = newEntry;
        newEntry.next.previous = newEntry;
        size++;
        modCount++;
        return newEntry;
    }

首先新建一個要新增的Entry，通過Entry的含參建構函式指定新Entry的next和prev結點，之後修改使新節點的prev結點的next結點指向自己，使新節點的next結點的prev結點指向自己，並返回新節點。

public void addLast(E e) {
    addBefore(e, header);
}

新增尾結點，原理如上。

public boolean add(E e) {
    addBefore(e, header);
        return true;
    }

新增結點，預設也是新增尾結點，原理如上。

public boolean contains(Object o) {
        return indexOf(o) != -1;
 }

其實現原理如下函式：

public int indexOf(Object o) {
        int index = 0;
        if (o==null) {
            for (Entry e = header.next; e != header; e = e.next) {
                if (e.element==null)
                    return index;
                index++;
            }
        } else {
            for (Entry e = header.next; e != header; e = e.next) {
                if (o.equals(e.element))
                    return index;
                index++;
            }
        }
        return -1;
}

就是從首節點開始向後遍歷，返回對應索引值，找不到則返回-1.

 public E get(int index) {
        return entry(index).element;
 }

獲取指定索引元素，實現原理如下函式：

 private Entry<E> entry(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+size);
        Entry<E> e = header;
        if (index < (size >> 1)) {
            for (int i = 0; i <= index; i++)
                e = e.next;
        } else {
            for (int i = size; i > index; i--)
                e = e.previous;
        }
        return e;
    }

如果索引值小於元素數量的一半，那麼久從前往後遍歷，如果索引值大於等於元素數量的一半，那麼從後往前遍歷。

 public E set(int index, E element) {
        Entry<E> e = entry(index);
        E oldVal = e.element;
        e.element = element;
        return oldVal;
    }

先通過索引獲取對應Entry，再修改元素值，並返回老元素值。

public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
}

也是先根據索引值獲取對應Entry，並將元素新增到該Entry前。

 public E peek() {
        if (size==0)
            return null;
        return getFirst();
    }

獲取首元素，與getFirst（）的區別是，如果當前連結串列中沒有元素，則返回null，而getFirst（）會報錯。

 public E element() {
        return getFirst();
    }

與getFirst（）相同

public E poll() {
        if (size==0)
            return null;
        return removeFirst();
    }

刪除首元素，與removeFirst（）的區別是，如果當前連結串列中沒有元素，則返回null，而removeFirst會報錯。

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

public boolean offer(E e) {
        return add(e);
    }

 public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

public boolean offerLast(E e) {
        addLast(e);
        return true;
    }

public E peekFirst() {
        if (size==0)
            return null;
        return getFirst();
    }

public E peekLast() {
        if (size==0)
            return null;
        return getLast();
    }

public E pollFirst() {
        if (size==0)
            return null;
        return removeFirst();
    }
public E pollLast() {
        if (size==0)
            return null;
        return removeLast();
    }

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

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

這些函式都很簡單，都是複用之前的實現，就不一一說明了。

LinkedList(jdk1.7和jdk1.8實現是相同的無區別)

未完待續、、