java.util.ArrayList

1. 類定義

//繼承了AbstractList類，並且實現了List,RandomAccess,Cloneable和java.io.Serializable接口
public class ArrayList<E> extends AbstractList<E> implements List<E>,RandomAccess,Cloneable,java.io.Serializable  

1. 域

//默認容量爲10
private static final int DEFAULT_CAPACITY=10;
//一個空的數組實例，用來構造空實例
private static final Object[] EMPTY_ELEMENTDATA={};
//ArrayList的存儲數組，如果是空ArrayList，則elementData==EMPTY_ELEMENTDATA
private transient Object[] elementData;
//元素個數
private int size;
//數組的最大存儲元素個數
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

1. 構造方法

//初始化一個容量爲initialCapacity的ArrayList
public ArrayList(int initialCapacity){
  super();
  if(initialCapacity<0)
   throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
  this.elementData=new Object[initialCapacity];                  
}
//構造一個ArrayList實例，存儲數組是空的
public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }
//用一個集合構造一個ArrayList實例
public ArrayList(Collection <? extends E> c){
 elementData = c.toArray();
 size=elementData.length;
 if(elementData.getClass!=Object[].class){
  elementData=Arrays.copayOf(elementData,size,Object[].class);
 }
}

1. 其他方法

//刪除ArrayList多餘的存儲空間（讓存儲能力剛好等於存儲的元素個數）
public void trimToSize(){
modCount++;
if(size < elementData.length){
 elementData = Arrays.copyOf(elmentData,size);
}
}

//確保ArrayList的最小容量，使得能存儲所有元素
public ensureCapacity(int minCapacity){
 int minExpand=(elementData!=EMPTY_ELEMENTDATA)?0:DEFAULT_CAPACITY;
 if(minCapacity>minExpand)
  ensureExplicitCapactiy(minCapacity);
}

 private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

//如果minCapacity大於數組容量，則將數組擴充到minCapacity
 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
//ArrayList容量真正擴充是在這個方法裏,正常情況下擴充爲原數組長度的3/2倍。如果新的長度還是小於minCapacity則，擴充到minCapacity。
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);
    }
//如果最小容量大於最大數組元素個數，則返回最大整數，否則返回最大數組元素個數
 private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
//返回ArrayList的元素個數
  public int size() {
        return size;
    }
  //判斷ArrayList是否爲空
 public boolean isEmpty() {
        return size == 0;
    }
  //是否包含o
  public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }
  //返回元素o所在位置，從數組頭開始遍歷，遇到第一個立即返回。給出的o可能爲空，所以不能全部用o.equasl，所以要根據o是否爲空選擇比較方法是==還是用equals,如果沒有找到o,則返回-1
  public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
//返回o最後出現的位置
public int lastIndexOf(Object o){
if(o==null){
  for(int i=size-1;i>=0;i--)
  if(elementData[i]==null)return i;
}
else {
  for(int i=size-1;i>=0;i--)
  if(elementData[i].equals(o))return i;
}
return -1;
}

public Object clone() {
        try {
            @SuppressWarnings("unchecked")
                ArrayList<E> v = (ArrayList<E>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError();
        }
    }

//返回ArryList的數組形式,返回的數組是一個新的數組，元素包含ArrayList的所有元素，但不是ArrayList本身數組的引用。即兩個數組沒有任何關係
public Object[] toArray(){
 return Arrays.copyOf(elementData,size);
}
//返回一個具體類型的包含ArrayList所有元素的數組
public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }
//返回數組具體位置的元素個數
E elementData(int index) {
        return (E) elementData[index];
    }
 //返回具體位置的元素個數，在返回前先要對輸入 的index做合法性判斷
public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }
//替換指定位置的元素,返回替換之前的元素
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);  //這個方法增加了modCount!!!
 elementData[size++]=e;
 return true;
}
//刪除指定位置的元素
public E remove(int index){
 rangeCheck(index);
            checkForComodification();
            E result = parent.remove(parentOffset + index);
            this.modCount = parent.modCount;
            this.size--;
            return result;
}