Collection是一個介面，它主要的兩個分支是List和Set。

List和Set都是介面，它繼承於Collection。
List是有序佇列，可以用重複的元素；
Set元素無序，並且不可重複；
List和Set都有他們各自的實現類

為了方便，我們抽象出AbstractCollection類來讓其他類繼承，該類實現類Collection中的絕大部分方法。AbstractList和AbstractSet都繼承與AbstractCollection，具體的List實現類繼承與AbstractList，而Set的實現類則繼承與AbstractSet。

另外，Collection中有個iterator()方法，它的作用是返回一個Iterator介面。通常，我們通過Iterator迭代器來遍歷集合。ListIterator是List介面所特有的，在List介面中，通過ListIterator()返回一個ListIterator物件。
我們首先來閱讀下這些 介面和抽象類以及他們的實現類中都有哪些方法：

1、Collection
Collection的定義如下：
public interface Collection extends Iterable{}
從他的定義中可以看出，Collection是一個介面，他是高度抽象出來的集合，包含了集合的基本操作：新增、刪除、清空、遍歷、是否為空，獲取大小等。
booleanadd(E o)
確保此 collection 包含指定的元素（可選操作）。booleanaddAll(Collection

下面看一下AbstractCollection實現的部分方法的原始碼：

public abstract class AbstractCollection implements Collection {
protected AbstractCollection() {
}

public abstract Iterator<E> iterator();//iterator()方法沒有實現  

public abstract int size(); //size()方法也沒有實現  

public boolean isEmpty() { //檢測集合是否為空  
    return size() == 0;  
}  
/*檢查集合中是否包含特定物件*/  
public boolean contains(Object o) {   
    Iterator<E> it = iterator();  
    if (o==null) {  
        while (it.hasNext()) //從這裡可以看出，任何非空集合都包含null  
            if (it.next()==null)  
                return true;  
    } else {  
        while (it.hasNext())  
            if (o.equals(it.next()))  
                return true;  
    }  
    return false;  
}  
/*將集合轉變成陣列*/  
public Object[] toArray() {  
    // Estimate size of array; be prepared to see more or fewer elements  
    Object[] r = new Object[size()]; //建立與集合大小相同的陣列  
    Iterator<E> it = iterator();  
    for (int i = 0; i < r.length; i++) {  
        if (! it.hasNext()) // fewer elements than expected  
            //Arrays.copy(**,**)的第二個引數是待copy的長度，如果這個長度大於r，則保留r的長度  
            return Arrays.copyOf(r, i);  
        r[i] = it.next();  
    }  
    return it.hasNext() ? finishToArray(r, it) : r;  
}  

public <T> T[] toArray(T[] a) {  
    // Estimate size of array; be prepared to see more or fewer elements  
    int size = size();  
    T[] r = a.length >= size ? a :  
              (T[])java.lang.reflect.Array  
              .newInstance(a.getClass().getComponentType(), size);  
    Iterator<E> it = iterator();  

    for (int i = 0; i < r.length; i++) {  
        if (! it.hasNext()) { // fewer elements than expected  
            if (a == r) {  
                r[i] = null; // null-terminate  
            } else if (a.length < i) {  
                return Arrays.copyOf(r, i);  
            } else {  
                System.arraycopy(r, 0, a, 0, i);  
                if (a.length > i) {  
                    a[i] = null;  
                }  
            }  
            return a;  
        }  
        r[i] = (T)it.next();  
    }  
    // more elements than expected  
    return it.hasNext() ? finishToArray(r, it) : r;  
}  

private static <T> T[] finishToArray(T[] r, Iterator<?> it) {  
    int i = r.length;  
    while (it.hasNext()) {  
        int cap = r.length;  
        if (i == cap) {  
            int newCap = cap + (cap >> 1) + 1;  
            // overflow-conscious code  
            if (newCap - MAX_ARRAY_SIZE > 0)  
                newCap = hugeCapacity(cap + 1);  
            r = Arrays.copyOf(r, newCap);  
        }  
        r[i++] = (T)it.next();  
    }  
    // trim if overallocated  
    return (i == r.length) ? r : Arrays.copyOf(r, i);  
}  

private static int hugeCapacity(int minCapacity) {  
    if (minCapacity < 0) // overflow  
        throw new OutOfMemoryError  
            ("Required array size too large");  
    return (minCapacity > MAX_ARRAY_SIZE) ?  
        Integer.MAX_VALUE :  
        MAX_ARRAY_SIZE;  
}  

// 刪除物件o  
public boolean remove(Object o) {  
    Iterator<E> it = iterator();  
    if (o==null) {  
        while (it.hasNext()) {  
            if (it.next()==null) {  
                it.remove();  
                return true;  
            }  
        }  
    } else {  
        while (it.hasNext()) {  
            if (o.equals(it.next())) {  
                it.remove();  
                return true;  
            }  
        }  
    }  
    return false;  
}  
 

    // 判斷是否包含集合c中所有元素 

    public boolean containsAll(Collection