• ArrayList提供了一宗可增長陣列的實現。有點事對get和set呼叫花費常數時間。缺點是插入和刪除代價昂貴，除非插入和刪除是在ArrayList的末端進行。
• LinkedList提供了雙鏈表實現。優點是，插入和刪除開銷很小，花費常數時間。缺點是不容易做索引，get和set呼叫昂貴，除非呼叫接近表的斷點的項(離哪端近就從哪端開始)。

這兩個集合主要是內部對資料的儲存方式不一樣，一個用的陣列，一個用的連結串列。

陣列和連結串列

關於數組合連結串列在之前有個簡單的比較

簡單陣列

array list

• 陣列可以使遍歷以線性時間執行O(N)。
• 查詢是常數時間O(1)。
• 不過插入和刪除開銷昂貴，如果發生在第一個元素上，時間是O(N)
  ,如果發生在最後一個元素上也就是高階，時間是O(1)

當插入和刪除都只對高階操作，陣列也比較合適，否則就應用 連結串列 linked list

簡單鏈表

使用連結串列是因為連結串列在記憶體中是不連續的，不用因為一個元素的插入或刪除而引起其他元素的變動。

連結串列由一系列節點組成，節點不需要在記憶體中相連，因此每一個節點除了自身元素外還要包含自己的後繼元的節點的鏈(link),稱之為next鏈。最後一個節點的next鏈引用null。

• 遍歷的時間是O(N),跟陣列一樣。
• 查詢的時間，因為需要從第一個節點開始查詢，所以時間也是線性的，O(N) 。要查詢第x個元素，花費的時間是O(x), 效率不如陣列。
• 刪除可以通過修改next鏈的引用來實現
• 插入也一樣，獲取一個新節點，修改兩個next鏈的引用，

刪除A2：

在A1後插入Ax：

雙鏈表

讓每一個節點擁有其前驅節點的引用就成了雙鏈表。

ArrayList和LinkedList

• ArrayList提供了一宗可增長陣列的實現。有點事對get和set呼叫花費常數時間。缺點是插入和刪除代價昂貴，除非插入和刪除是在ArrayList的末端進行。
• LinkedList提供了雙鏈表實現。優點是，插入和刪除開銷很小，花費常數時間。缺點是不容易做索引，get和set呼叫昂貴，除非呼叫接近表的斷點的項(離哪端近就從哪端開始)。

ArrayList的實現

• 內部使用陣列來儲存資料，有一個預設的陣列容量
• 當容量不夠的時候，擴容一個新陣列，將老資料複製到新陣列，釋放舊陣列。
• 內部類實現 MyIterator
• 增強for迴圈的實現 implements Iterable

import java.util.Arrays;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.function.Consumer;

/**
 * @author sll on 2017/6/30.
 */
public class MyArrayList<Element> implements Iterable<Element> {
    private static final int DEFAULT_CAPACITY = 5;
    private int size;
    private Element[] elements;
    private int modCount = 0;

    public MyArrayList() {
        elements = (Element[]) new Object[DEFAULT_CAPACITY];
        clear();
    }

    public void clear() {
        size = 0;
        ensureCapacity(DEFAULT_CAPACITY);
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void trimToSize() {
        ensureCapacity(size);
    }

    //這裡是查詢，使用陣列直接就查出來了，所以一次查詢的時間是 O(1)
    public Element get(int index) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException();
        }
        return elements[index];
    }

    public Element set(int index, Element newElement) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException();
        }
        Element old = elements[index];
        elements[index] = newElement;
        return old;
    }

    public boolean add(Element e) {
        return add(size, e);
    }


    //這裡的增加和刪除就要移動很多項，所以一次插入或刪除的速度是 O(N)
    public boolean add(int index, Element e) {
        if (elements.length == size) {
            ensureCapacity(size * 2 + 1);
        }
        System.arraycopy(elements, index, elements, index + 1, size - index);
        elements[index] = e;
        size++;
        modCount++;
        return true;
    }

    public Element remove(int index) {
        Element removeElement = elements[index];
        int moveNum = size - index - 1;
        if (moveNum > 0) {
            System.arraycopy(elements, index + 1, elements, index, moveNum);
        }
        size--;
        elements[size] = null;
        modCount++;
        return removeElement;
    }

    public void ensureCapacity(int newCapacity) {
        if (newCapacity < size)
            return;
        elements = Arrays.copyOf(elements, newCapacity);
    }


    public Itr iterator() {
        return new Itr();
    }


    private class Itr implements Iterator<Element> {
        private int exceptMocCount = modCount;
        private int current = 0;

        @Override
        public boolean hasNext() {
            return current < size();
        }

        @Override
        public Element next() {
            if (exceptMocCount != modCount) {
                throw new ConcurrentModificationException();
            }
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return elements[current++];
        }

        @Override
        public void remove() {
            if (exceptMocCount != modCount) {
                throw new ConcurrentModificationException();
            }
            MyArrayList.this.remove(--current);
        }

        @Override
        public void forEachRemaining(Consumer<? super Element> action) {

        }
    }
}

LinkedList的實現

• 使用雙鏈表來實現
• 節點類Node，為私有靜態內部類（巢狀類）,包含資料和前後節點的鏈
• 有兩個額外的節點，頭節點和尾節點，中間才是資料
• 內部實現MyIterator
• 增強for迴圈的實現 implements Iterable
• 對add和remove增加一個計數modCount，在迭代器的hasNext和next中比較這個計數，不同就說明這個集合被修改了，就丟擲異常ConcurrentModificationException。

import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * @author sll on 2017/6/30.
 */
public class MyLinkedList<E> implements Iterable<E> {

    private int theSize = 0;
    private int modCount = 0;
    private Node<E> startNode, endNode;//額外的頭節點和尾節點

    public MyLinkedList() {
        clear();
    }

    private void clear() {
        startNode = new Node(null, null, null);
        endNode = new Node(null, startNode, null);
        startNode.next = endNode;
        theSize = 0;
        modCount++;
    }

    public int size() {
        return theSize;
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean add(E x) {
        return add(size(), x);
    }

    public boolean add(int index, E x) {
        addBefore(getNode(index), x);
        return true;
    }

    public E get(int index) {
        return getNode(index).data;
    }

    public E set(int index, E x) {
        Node<E> p = getNode(index);
        E old = p.data;
        p.data = x;
        return old;
    }

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


    private void addBefore(Node<E> p, E x) {
        Node<E> newNode = new Node<>(x, p.prev, p);
        newNode.prev.next = newNode;
        p.prev = newNode;
        theSize++;
        modCount++;
    }

    private Node<E> getNode(int index) {
        Node<E> p;
        if (index < 0 || index > size())
            throw new IndexOutOfBoundsException();
        if (index < size() / 2) {
            p = startNode.next;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
        } else {
            p = endNode;
            for (int i = size(); i > index; i--) {
                p = p.prev;
            }
        }

        return p;
    }

    private E remove(Node<E> x) {
        x.prev.next = x.next;
        x.next.prev = x.prev;
        theSize--;
        modCount++;
        return x.data;
    }

    @Override
    public Iterator<E> iterator() {
        return new MyIterator();
    }

    private static class Node<E> {
        public E data;
        public Node<E> prev;
        public Node<E> next;

        public Node(E data, Node<E> prev, Node<E> next) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }
    }

    private class MyIterator implements Iterator<E> {
        private Node<E> current = startNode.next;
        private int expectedModCount = modCount;
        private boolean okToRemove = false;

        @Override
        public boolean hasNext() {
            return current!= endNode;
        }

        @Override
        public E next() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            E nextItem = current.data;
            current = current.next;
            okToRemove = true;
            return nextItem;
        }

        @Override
        public void remove() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (!okToRemove) {
                throw new NoSuchElementException();
            }
            MyLinkedList.this.remove(current.prev);
            okToRemove = false;
            expectedModCount++;
        }

    }


}

時間對比

以分別用ArrayList和LinkedList用下面三個方法做一個時間對比：

//從末端新增，建立一個由N個項的List。
public static void makeList1(List<Integer> list, int N) {
    list.clear();
    for (int i = 0; i < N; i++) {
        list.add(i);
    }
}

//從首端新增，建立一個由N個項的List。
public static void makeList2(List<Integer> list, int N) {
    list.clear();
    for (int i = 0; i < N; i++) {
        list.add(0, i);
    }
}

//獲取長度為N的List的每一個值求和。
public static void makeList3(List<Integer> list) {
    long total = 0;
    for (int i = 0; i < list.size(); i++) {
        total += list.get(i);
    }
}

首先建立兩個集合，N=100000，列印耗費時間(ms)：

List<Integer> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<Integer>();

• makeList1

  makeList1(arrayList, 100000);
  makeList1(linkedList, 100000);

結果可能會不一樣，但也是相近的。

執行時間都是O(N)

• makeList2

  makeList2(arrayList, 100000);
  makeList2(linkedList, 100000);

linkedList花費的時間少得多，執行時間是O(N)

而ArrayList因為每次在頭部插入都需要將之前所有項向後移動一位，所以執行時間是O(N^2)

• makeList3

  makeList2(arrayList, 100000);
  makeList2(linkedList, 100000);
  
  makeList3(arrayList);
  makeList3(linkedList);

​ 這個每次都要查詢，所以ArrayList比較快，執行時間是O(N)

​ 而inkedList的執行時間是O(N^2)

• 用迭代器實現makeList3

  將makeList3改成：

  public static void makeList3(List<Integer> list) {
        long total = 0;
        for (Integer i : list) {
            total+=i;
        }
    }

​ 兩個都很相近了，都是O(N)。

參考《資料結構與演算法分析java版》