ArrayList概述
1.ArrayList是基于數(shù)組實現(xiàn)的缰儿，是一個動態(tài)數(shù)組畦粮，與Java的數(shù)組相比散址，它的容量可以自動增長擴容乖阵。
2.ArrayList實現(xiàn)了RandomAccess（支持隨機快速訪問宣赔，通過序列號訪問元素內(nèi)容），實現(xiàn)了Cloneable（可以被克碌山）儒将，實現(xiàn)了Serializable（可以被序列化）。
3.ArrayList不是線程安全的对蒲，最好在單線程情況下使用钩蚊，多線程的情況下考慮用concurrent并發(fā)包下面的CopyOnWriteArrayList類或者Vector類，或者通過Collections.synchronizedList(list)函數(shù)返回一個線程安全的ArraList類
構(gòu)造函數(shù)
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0) // 如果initialCapacity>0就給定一個 initialCapacity大小的數(shù)組
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
private static final Object[] EMPTY_ELEMENTDATA = {};
public ArrayList() {
super();
this.elementData = EMPTY_ELEMENTDATA; // 給定一個空數(shù)組
}
// 構(gòu)造一個包含指定元素的list蹈矮，這些元素是按照C的迭代器返回的順序排列的
public ArrayList(Collection<? extends E> paramCollection)
{
this.elementData = paramCollection.toArray(); //轉(zhuǎn)換
if ((this.size = this.elementData.length) != 0)
{
if (this.elementData.getClass() != [Ljava.lang.Object.class) { // 不是Object類型就強制轉(zhuǎn)換為Object類型
this.elementData = Arrays.copyOf(this.elementData, this.size, [Ljava.lang.Object.class);
}
}
else {
this.elementData = EMPTY_ELEMENTDATA;
}
}
添加
public boolean add(E e) {
// 增加一個元素首先得保證底層數(shù)組不越界
ensureCapacityInternal(size + 1); // 增加modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
// 之前使用的是ArrayList()作為構(gòu)造函數(shù)的話砰逻，第一次擴展把空數(shù)組擴展成size=10的數(shù)組
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
// 數(shù)組容量檢查，不夠時則進行擴容
private void ensureExplicitCapacity(int minCapacity) {
//這個變量記錄了對ArrayList修改的次數(shù)(Fail-Fast 就是檢測的這個變量)
modCount++;
// overflow-conscious code
// 當(dāng)前數(shù)組沒有更多容量了泛鸟，則需要動態(tài)擴展
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
// 即newCapacity =1.5倍oldCapacity蝠咆，所以ArrayList每次動態(tài)擴展是1.5倍的擴展
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// ArrayList不適合Add很多的場景，每當(dāng)?shù)讓訑?shù)組擴容后需要把所有的元素從老數(shù)組copy到新數(shù)組
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
添加(指定下標)
public void add(int index, E element) {
rangeCheckForAdd(index); // 判斷輸入的下標是否越界
ensureCapacityInternal(size + 1); // 增加 modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index); // 需要把指定位置后面的所有元素都往后移動一個位置北滥，所以也是比較低效的刚操。
elementData[index] = element; // 指定位置存放元素
size++;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
讀取
public E get(int index) {
rangeCheck(index); // 判斷索引是否越界
return elementData(index); // 返回指定索引的值
}
/**
*檢查給定的索引是否在范圍內(nèi)。如果沒有再芋，就拋出一個適當(dāng)?shù)? *運行時異常菊霜。該方法不檢查索引是否為
*否定:在數(shù)組訪問之前，它總是被立即使用济赎，
*拋出ArrayIndexOutOfBoundsException如果指數(shù)是負的鉴逞。
*/
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
修改
public E set(int index, E element) {
rangeCheck(index); // 判斷索引是否越界
E oldValue = elementData(index); // 取得舊的值
elementData[index] = element; // 設(shè)為新的值
return oldValue; // 返回舊的值
}
刪除
public E remove(int index) {
rangeCheck(index); // 判斷索引是否越界
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0) // 把index后面的元素整體向前移動，可以看出這步是非常耗資源的
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 放棄對最后一個元素的引用司训，讓GC能回收掉它
elementData[--size] = null; // clear to let GC do its work
return oldValue; // 返回被刪除的那個元素
}
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) { // 刪除數(shù)組中所有null的元素
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {// 比較相等 然后刪除
fastRemove(index);
return true;
}
}
return false;
}
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0) // 把index后面的元素整體向前移動华蜒，可以看出這步是非常耗資源的
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 放棄對最后一個元素的引用，讓GC能回收掉它
elementData[--size] = null; // clear to let GC do its work
}
