JAVA集合的框架圖:

從圖中可以看出集合分為collection 和 map 兩大類, 其中collection內部主要以陣列或者連結串列的形式存放一系列集合物件,map則是以系列鍵值對的集合

collection主要包含list 和 set 兩個部分,是list和set 高度抽象出來的介面,主要包含add() remove() contains()等集合基本方法,還包含一個iterator() 方法,

依賴iterator介面,可以用來對集合進行遍歷

AbstractCollection是一個抽象類, 實現了collection中的部分方法,比如:

    public boolean isEmpty() {
	return size() == 0;
    }
    public boolean contains(Object o) {
	Iterator<E> e = iterator();
	if (o==null) {
	    while (e.hasNext())
		if (e.next()==null)
		    return true;
	} else {
	    while (e.hasNext())
		if (o.equals(e.next()))
		    return true;
	}
	return false;
    }
 

其中用到的siez()方法,以及iterator()等方法,則由具體的子類實現,比如list或者set

AbstractList 和 AbstractSet 則分別實現了List 和 Set介面,並都繼承自AbstractCollection

List中我們用的最多的是ArrayList和LinkedList , ArrayList內部使用陣列實現,而LinkedList則使用連結串列的方式實現, 

先看看ArrayList的部分原始碼:

private static final int DEFAULT_CAPACITY = 10;
transient Object[] elementData;
private int size;

    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
 

如果初始化時不指定大小,則預設初始化一個無內容的陣列,指定了大小,則根據指定大小進行初始化, 其中size用來表示陣列實際長度

我們先看看add方法

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

 第一個是直接加在陣列後面,第二個是加在指定下標的位置,arraylist可以根據下標直接定位,所以查詢效率很高,但是在新增和刪除的時候,效率非常低

原因是因為新增和刪除的時候,如果不是從最後一個下標開始操作,那麼需要將指定下標後面所有的元素都進行移動

		List list = new ArrayList(100000);
		//List list = new LinkedList();
		long s1 = System.currentTimeMillis();
		for(int i=0; i<100000; i++) {
			list.add(0,i);
		}
		long s2 = System.currentTimeMillis();
		System.out.println(s2 - s1);

我用這段程式碼進行測試,時間是1123多毫秒,但是我如果把list.add(0,i) 這段程式碼直接改成list.add(i),那麼直需要5毫秒左右

並且隨著陣列容量增加,所需數量會呈指數級增長,所以我們如果需要對list從中間進行新增,刪除操作,那麼儘量使用linkedlist

上面這段程式碼如果把new Arraylist() 直接用new LinkedList()來代替, 兩種add方法需要的時間都在幾毫秒左右

list每次在新增時,必須先對其容量進行計算, ensureCapacityInternal(size + 1) ,如果超出容量,則需進行擴容

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//預設初始容量為10,取所需容量和初始容量的最大值
        }

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

        // 當所需容量大於陣列初始的長度時,需要進行擴容操作
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        // 擴容一般為原來的1.5倍,如果還不夠,那麼直接取所需容量進行操作,進行擴容操作需要對整個陣列進行移動,效能較差,所以儘可能確定初始容量
        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);
    }

arraylist的get可以直接定位下標,從陣列中取值,所以效率很高:public E get(int index) {rangeCheck(index);return elementData(index);}

再看看linkedlist的原始碼:

//首先定義了頭尾2個節點,這裡原始碼來自jdk1.8,1.6的原始碼裡面是直接定義了一個head節點並且 頭尾都指向自己,作為一個雙向連結串列
transient Node<E> first;
transient Node<E> last;

//node節點的定義,其實就是一個指定的物件,再加上前後指標
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

linkedlist的add比較簡單,先判斷 頭節點是否為空,如果頭節點為空,那麼直接將新增的節點作為頭節點,如果不為空,則將頭節點的next指向這個節點,這個節點的next指向原來 頭結點的next,prev也按類似的邏輯進行操作.

linkedlist由於是基於連結串列的,沒有arraylist裡面的擴容操作,新增和刪除都只需要修改幾個指標的指向就行,所以新增和刪除效率高

但是查詢的時候,由於沒有下標,那麼只能通過遍歷來進行比較,所以效率非常低

list中的另一個實現:vector,其基本實現原理和arraylist差不多,但是他在很多方法中加入了synchronized來保證執行緒安全,所以效率低

而且很多情況,這個synchronized其實沒法真正保證執行緒安全(比如size()方法和add(E e)都單獨加了同步,但是我們如果需要先判斷size()然後再add,那麼在多執行緒的情況下,這2個方法執行的間隙,就有可能被其他執行緒修改了資料), 所以vector現在基本被棄用了, 如果需要使用執行緒安全的集合,應該首選java.util.Concurrent下面的相關集合