解析java.util集合類源碼(Collection和AbstractCollection篇)

本篇爲對java.util包下的集合知識總結，從jdk中Collection接口到ArrayList實體類

從結構上來看

接口Collection

Collection是所有集合類的最上層接口，繼承了Iterable接口便於迭代，接口中定義了許多方法都是集合的添加，刪除，包含元素，清空，添加集合等等一些對集合的操作，抽象了幾乎所有集合需要用到的方法，細節在實現類和抽象類詳細說明。

抽象類AbstractCollection

AbstractCollection抽象類實現了Collection接口，基本上主要的方法中都使用的Iterator進行集合的遍歷，Iterator的實現放在子類中，實現多態。

  public abstract Iterator<E> iterator();

  public abstract int size();

 將兩個抽象方法放到子類的去實現，同時實現了一些可以在所有Collection集合中共有的方法

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

通過子類實現的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;
    }

通過迭代當前集合，判斷集合中是否有o元素

ps:

1.  在ArrayList中實現Iterator的內部類Itr， e.hasNext()方法判斷的是通過判斷當前迭代個數是否達到了size()的值，從而判斷能否迭代，而e.next()方法返回的是那個存在於集 閤中的那個對象，是有可能爲Null的，所有當o爲null時，在collection中也有一個null的對象會返回true

2. 在o.equals(e.next())時，應當注意該類是否重寫了equals方法，否則只有當引用值相等時纔會返回true

 public Object[] toArray() {
        // Estimate size of array; be prepared to see more or fewer elements
	Object[] r = new Object[size()];    //新建一個size()大小的Object數組
        Iterator<E> it = iterator();  
	for (int i = 0; i < r.length; i++) {
	    if (! it.hasNext())	// 如果在遍歷的時候集合中的元素減少了，
		return Arrays.copyOf(r, i);  //返回一個長度爲i的數組
	    r[i] = it.next();
	}
	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 / 2) + 1) * 3;  //重寫數組長度
                if (newCap <= cap) { // integer overflow
		    if (cap == Integer.MAX_VALUE)  //超過int的最大值，拋異常
 			throw new OutOfMemoryError("Required array size too large");
		    newCap = Integer.MAX_VALUE;
		}
		r = Arrays.copyOf(r, newCap);  //重新分配數組
	     }
	    r[i++] = (T)it.next();  
        }
        // 長度過多，截取數組
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }

在toArray方法中，爲何不直接將存儲數據的數組返回?在ArrayList中數據使用一個Object數組作爲存儲數據池，可其他集合類中不一定有同樣的存儲方式，但所有的集合類中都實現Iterable接口，使用這個接口獲取迭代器，對集合進行遍歷，在AbstractCollection抽象類中用通用的迭代的方法，保證下層所有的實現類都可用。動態數組的核心代碼分析不在Arrays.copyOf(r, i)不在這裏詳細分析。在循環過程中可能Iterator中的元素有增加、刪除的改變，當元素減少時，數組循環未結束，但是Iterator的迭結束，這時候截取數組，但是元素增加時候，調用finifshToArray(T[] r,Iterator<?> it)在數組添加爲遍歷到的元素

    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 :  //若傳參的數組比集合中元素的個數多，將數組付給r，否則，分配一個新的大小爲size 的數組
                  (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)  //新建的數組
		    return Arrays.copyOf(r, i);
		    r[i] = null; // 在末尾添加一個null的結束符
		return r;
	    }
	    r[i] = (T)it.next();
	}
	return it.hasNext() ? finishToArray(r, it) : r;
    }

toArray(T[] a)方法與toArray()方法相似，同是遍歷集合放回數組，不同的是在這個方法中有一個帶有長度和類型的數組

 

 public boolean add(E e) {
	throw new UnsupportedOperationException();
    }

add方法中只拋出了一個UnsupportedOperationException異常，說明子類要使用此方法必須重寫add方法，否則會報出不可執行的異常

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

remove(Object o)方法中，主要Iterator中的remove()刪除集合中元素

 public boolean containsAll(Collection<?> c) {
	Iterator<?> e = c.iterator();
	while (e.hasNext()) //迭代整個外部傳參的Collection
	    if (!contains(e.next()))  //調用AbstractCollection中contains方法
		return false;
	return true;  //只有將整個外部的Collection都遍歷，並且其中元素都存在此集合
    }

containsAll(Collection<?> c)方法中，也主要是使用Iterator和本類中contains方法，判斷外部的Collection集合是否都在集合中

public boolean addAll(Collection<? extends E> c) {
	boolean modified = false;
	Iterator<? extends E> e = c.iterator();
	while (e.hasNext()) {
	    if (add(e.next()))  //add方法必須由子類實現
		modified = true;
	}
	return modified;
    }

addAll(Collection <? extends E> c)方法，調用子類實現的add方法，若有一個元素添加成功，就返回true

  public boolean removeAll(Collection<?> c) {
	boolean modified = false;
	Iterator<?> e = iterator();
	while (e.hasNext()) {
	    if (c.contains(e.next())) {  //先判斷存在
		e.remove();  //若存在刪除
		modified = true;
	    }
	}
	return modified;
    }

removeAll(Collection<?> c)和addAll方法相似，在刪除前需要先進性判斷

public boolean retainAll(Collection<?> c) {
	boolean modified = false;
	Iterator<E> e = iterator();
	while (e.hasNext()) {
	    if (!c.contains(e.next())) {
		e.remove();
		modified = true;
	    }
	}
	return modified;
    }

retainAll(Collection<?> c)方法刪除集合中不在外部集合的元素

 public void clear() {
	Iterator<E> e = iterator();
	while (e.hasNext()) {
	    e.next();
	    e.remove();
	}
    }

clear()清空集合元素

public String toString() {
        Iterator<E> i = iterator();
	if (! i.hasNext())  //集合是空的
	    return "[]";

	StringBuilder sb = new StringBuilder();
	sb.append('[');
	for (;;) {
	    E e = i.next();
	    sb.append(e == this ? "(this Collection)" : e);
	    if (! i.hasNext())
		return sb.append(']').toString();
	    sb.append(", ");
	}
    }

重寫toString()方法