概念
ArrayList是我們常用的集合類，是基于數(shù)組實現(xiàn)的。不同于數(shù)組的是ArrayList可以動態(tài)擴容。
類結(jié)構(gòu)
ArrayList是Java集合框架List接口的一個實現(xiàn)類。提供了一些操作數(shù)組元素的方法。
實現(xiàn)List接口同時，也實現(xiàn)了 RandomAccess, Cloneable, java.io.Serializable。
ArrayList繼承與AbstractList。
類成員
elementData
transient Object[] elementData;
elementData是用于保存數(shù)據(jù)的數(shù)組，是ArrayList類的基礎。
elementData是被關(guān)鍵字transient修飾的。我們知道被transient修飾的變量，是不會參與對象序列化和發(fā)序列化操作的。而我們知道ArrayList實現(xiàn)了java.io.Serializable，這就表明ArrayList是可序列化的類，這里貌似出現(xiàn)了矛盾。
ArrayList在序列化和反序列化的過程中，有兩個值得關(guān)注的方法：writeObject和 readObject：
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in capacity
s.readInt(); // ignored
if (size > 0) {
// be like clone(), allocate array based upon size not capacity
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
writeObject會將ArrayList中的size和element數(shù)據(jù)寫入ObjectOutputStream。readObject會從ObjectInputStream讀取size和element數(shù)據(jù)。
之所以采用這種序列化方式，是出于性能的考量。因為ArrayList中elementData數(shù)組在add元素的過程，容量不夠時會動態(tài)擴容，這就到可能會有空間沒有存儲元素。采用上述序列化方式，可以保證只序列化有實際值的數(shù)組元素，從而節(jié)約時間和空間。
size
private int size;
size是ArrayList的大小。
DEFAULT_CAPACITY
/**
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;
ArrayList默認容量是10。
構(gòu)造函數(shù)
ArrayList提供了2個構(gòu)造函數(shù)ArrayList(int initialCapacity)和 ArrayList()。
使用有參構(gòu)造函數(shù)初始化ArrayList需要指定初始容量大小，否則采用默認值10。
add()方法
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
在add元素之前，會調(diào)用ensureCapacityInternal方法，來判斷當前數(shù)組是否需要擴容。
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 如果elementData為空數(shù)組，指定elementData最少需要多少容量。
// 如果初次add，將取默認值10；
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
// elementData容量不足的情況下進行擴容
if (minCapacity - elementData.length > 0)
grow(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);
}
從
grow方法中可以看出，ArrayList的elementData數(shù)組如遇到容量不足時，將會把新容量newCapacity設置為oldCapacity + (oldCapacity >> 1)。二進制位操作>> 1等同于/2的效果，擴容導致的newCapacity也就設置為原先的1.5倍。如果新的容量大于
MAX_ARRAY_SIZE。將會調(diào)用hugeCapacity將int的最大值賦給newCapacity。不過這種情況一般不會用到，很少會用到這么大的ArrayList。
在確保有容量的情況下，會將元素添加至elementData數(shù)組中。
add(int index, E element) 方法
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++;
}
帶有index的add方法相對于直接add元素方法會略有不同。
- 首先會調(diào)用
rangeCheckForAdd來檢查，要添加的index是否存在數(shù)組越界問題； - 同樣會調(diào)用
ensureCapacityInternal來保證容量； - 調(diào)用
System.arraycopy方法復制數(shù)組，空出elementData[index]的位置； - 賦值并增加
size；
remove(int index) 方法
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
ArryList提供了兩個刪除List元素的方法，如上所示，就是根據(jù)index來刪除元素。
- 檢查
index是否越界； - 取出原先值的，如果要刪除的值不是數(shù)組最后一位，調(diào)用
System.arraycopy方法將待刪除的元素移動至elementData最后一位。 - 將
elementData最后一位賦值為null。
remove(Object o) 方法
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
remove(Object o)是根據(jù)元素刪除的，相對來說就要麻煩一點：
- 當元素
o為空的時候，遍歷數(shù)組刪除空的元素。 - 當元素
o不為空的時候，遍歷數(shù)組找出于o元素的index，并刪除元素。 - 如果以上兩步都沒有成功刪除元素，返回
false。
modCount
在add、remove過程中，經(jīng)常發(fā)現(xiàn)會有modCount++或者modCount--操作。這里來看下modCount是個啥玩意。
modCount變量是在AbstractList中定義的。
protected transient int modCount = 0;
modCount是一個int型變量，用來記錄ArrayList結(jié)構(gòu)變化的次數(shù)。
modCount起作用的地方是在使用iterator的時候。ArrayList的iterator方法。
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
iterator方法會返回私有內(nèi)部類Itr的一個實例。這里可以看到Itr類中很多方法，都會調(diào)用checkForComodification方法。來檢查modCount是夠等于expectedModCount。如果發(fā)現(xiàn)modCount != expectedModCount將會拋出ConcurrentModificationException異常。
這里寫一個小例子來驗證體會下modCount的作用。簡單介紹一下這個小例子：準備兩個線程t1、t2，兩個線程對同一個ArrayList進行操作，t1線程將循環(huán)向ArrayList中添加元素，t2線程將把ArrayList元素讀出來。
Test類：
public class Test {
List<String> list = new ArrayList<String>();
public Test() {
}
public void add() {
for (int i = 0; i < 10000; i++) {
list.add(String.valueOf(i));
}
}
public void read() {
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
t1線程：
public class Test1Thread implements Runnable {
private Test test;
public Test1Thread(Test test) {
this.test = test;
}
public void run() {
test.add();
}
t2線程：
public class Test2Thread implements Runnable {
private Test test;
public Test2Thread(Test test) {
this.test = test;
}
public void run() {
test.read();
}
}
main類
public static void main(String[] args) throws InterruptedException {
Test test = new Test();
Thread t1 = new Thread(new Test1Thread(test));
Thread t2 = new Thread(new Test2Thread(test));
t1.start();
t2.start();
}
執(zhí)行這個mian類就會發(fā)現(xiàn)程序?qū)伋鲆粋€ConcurrentModificationException異常。
由異常可以發(fā)現(xiàn)拋出異常點正處于在調(diào)用next方法的checkForComodification方法出現(xiàn)了異常。這里也就出現(xiàn)上文描述的modCount != expectedModCount的情況，原因是t2線程在讀數(shù)據(jù)的時候，t1線程還在不斷的添加元素。
這里modCount的作用也就顯而易見了，用modCount來規(guī)避多線程中并發(fā)的問題。由此也可以看出ArrayList是非線程安全的類。
