本人大二學生黨，最近研究JDK原始碼，順便複習一下資料結構與演算法的知識，所以就想寫這些系列文章。這是[Java Collection原始碼+演算法+資料結構]系列的第二篇。
上篇文章中，瞭解了Map的基本原理，現在我們來了解List家族。

簡述

An ordered collection (also known as a sequence). The user of this interface has precise control over where in the list each element is inserted. The user can access elements by their integer index (position in the list), and search for elements in the list.

List就是一個列表，可以儲存重複值，可以儲存null。且List介面繼承了Collection介面，下面看看Collection。

The root interface in the collection hierarchy. A collection represents a group of objects, known as its elements. Some collections allow duplicate elements and others do not. Some are ordered and others unordered. The JDK does not provide any direct implementations of this interface: it provides implementations of more specific subinterfaces like Set

and List. This interface is typically used to pass collections around and manipulate them where maximum generality is desired.

Collection是類集框架的root，List與Set都是繼承Collection的，但是Collection介面本身沒什麼卵用。。所以還是繼續回到List裡面把。

ArrayList

ArrayList是我們用的最多的一個實現類，下面一起走進去看看原始碼
要點1：

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
 

     */
    private int size;
     /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access

可以看到List採用陣列儲存資料，就和Array相對應咯，然後size屬性是儲存元素的個數（真正的有多少個元素，而不是elementData的大小，因為elementData.length為elementData佔用了多少的記憶體塊，可以有些沒有儲存物件，所以size表示真正的元素的個數）

要點2：

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

List和Map一樣（Map預設16， 2＜＜４），也是有預設的長度的，不夠的時候就會擴容。怎麼擴容呢？在每此向List裡面新增元素的時候，就會去檢查是否超出了容量。

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    /**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

最終在grow裡面可以明確的看到卻是擴容了，
int newCapacity = oldCapacity + (oldCapacity >> 1);也就是擴大了1.5倍（那麼思考一哈：HashMap一次擴容多少呢?）。
但是擴容了就有一個問題—–會有多餘的空間，而這些空間卻沒有儲存物件。如果當記憶體不足的時候，就是一個麻煩的事啦，別怕。

    /**
     * Trims the capacity of this <tt>ArrayList</tt> instance to be the
     * list's current size.  An application can use this operation to minimize
     * the storage of an <tt>ArrayList</tt> instance.
     */
    public void trimToSize() {
        modCount++;
        //真正的元素的個數 < elementData的大小
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
              //在這裡呼叫Array.copyOf(T[] original, int newLength)之後會進行說明
        }
    }

這樣就會把那些多餘的空間給釋放掉咯。

要點3：
那麼List怎麼新增資料，修改資料，刪除資料呢？
下面進入程式碼裡面看看：

    //先檢查是否index越界，然後想陣列一樣直接取
    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }
    //修改資料
    //先檢查是否index越界,然後存進去返回oldValue
    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
    //首先檢查容量是否足夠，然後再存進去
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;

    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

上面的程式碼應該都不難，只有有一個函式需要注意：
System.arraycopy()與Arrays.copyOf()。下面進去看一哈：

    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

    /* @param      src      the source array.
     * @param      srcPos   starting position in the source array.
     * @param      dest     the destination array.
     * @param      destPos  starting position in the destination data.
     * @param      length   the number of array elements to be copied. */
    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

在copyOf方法裡面我們可以看到重新建立了一個copy陣列，然後再呼叫arraycopy方法。arraycopy方法還是很好理解的，是一個native方法。copyOf方法可以看成arraycopy的一個封裝。所以我們只需要瞭解copyOf方法。下面看看怎麼用的：

    @Test
    public void testCopy() {
        int[] arr = {1, 2, 3, 4, 5};

        int[] copied = Arrays.copyOf(arr, 10); //產生了一個新的陣列
        System.out.println(Arrays.toString(copied));

        copied = Arrays.copyOf(arr, 3);
        System.out.println(Arrays.toString(copied));
    }

輸出：

[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[1, 2, 3]

LinkedList

LinkedList其實是一個雙向連結串列，但是由於實現了Deque介面，可以看作佇列，也可以看出棧。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

下面看看佇列是怎麼實現的：
Queue：
- offer() 入佇列
- poll() 出佇列，然後刪除對首元素
- peek() 取對首元素，但不刪除對收元素
- element() 取對首元素，與peek()的區別就是element()不能返回null

Stack：
- push()壓棧
- pop()出棧（刪除）
- peek()出棧（不刪除）
- element()出棧（不刪除，而且不能為null）

下面一起看看這些方法：

     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 boolean offer(E e) {
        return add(e);
    }
     public void push(E e) {
        addFirst(e);
    }
    public E pop() {
        return removeFirst();
    }

還是呼叫的其他方法：

    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }
    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }
    /**
     * Unlinks non-null node x.
     */
    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;
    }

    /**
     * Links e as first element.
     */
    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;
        size++;
        modCount++;
    }

    /**
     * Links e as last element.
     */
    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++;
    }

到頭還是2個方法，在連結串列的頭部和連結串列的尾部進行操作，沒什麼好說的啦。

比較

首先看看ArrayList的簽名：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

哦豁！RandomAccess是什麼鬼？

/**
 * Marker interface used by <tt>List</tt> implementations to indicate that
 * they support fast (generally constant time) random access.  The primary
 * purpose of this interface is to allow generic algorithms to alter their
 * behavior to provide good performance when applied to either random or
 * sequential access lists.
 **/
public interface RandomAccess {
}

這是一個標記介面，和Serializable一樣，實現這個介面代表可以實現fast (generally constant time) random access。主要目的就是幫助演算法改進其行為。

if(list instanceof RandomAccess){
    for (int i=0, n=list.size(); i++)
          list.get(i);
}
else{
    for (Iterator i=list.iterator(); i.hasNext(); )
          i.next();
}

對於實現RandomAccess介面的，上面的遍歷比下面的快，所以可以通過instanceof關鍵字來判斷使用那種方法遍歷。
參考文獻
所以對於ArrayList使用for迴圈變數最快
LinkedList使用foreach或者iterator遍歷快
（HashMap使用EntrySet+foreach遍歷最快啦）

郵箱：[email protected]