java集合类（二）List之ArrayList

ArrayList概述：

　　ArrayList是List接口基于数组的实现。它允许包括 null 在内的所有元素。每个ArrayList实例都有一个容量，该容量代表可以存储元素的多少。每个ArrayList实例都有一个初始大小，当然你也可以通过构造方法指定初始大小。随着向ArrayList中不断添加元素，其容量也自动增长。当元素数量达到当前容量最大值时会导致数据向新数组的重新拷贝，因此，如果可预知数据量的多少，可在构造ArrayList时指定其容量。在添加大量元素前，应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量，这可以减少递增式再分配的数量。 但是需要注意，此方法的实现不是同步的。如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。

底层探究

1 初始容量

private static final int DEFAULT_CAPACITY = 10;

2 底层存储

/**
*Object类型数组
*/
transient Object[] elementData;

3 构造方法

/**
* 指定初始容量
*/
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);
}
}

/**
* 默认构造，初始容量为10
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
* 使用一个集合初始化一个ArrayList
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
this.elementData = EMPTY_ELEMENTDATA;
}
}

4 存储

　　ArrayList提供了set(int index, E element)、add(E e)、add(int index, E element)、addAll(Collection

//设置指定位置元素的值(可理解为更新操作)
set(int index, E element)

//往集合中添加元素，如果容量不足则扩容
add(E e)

//往指定位置插入元素，如果容量不足则先扩容。原先index及之后的元素均往后移动一位
add(int index, E element)

5 删除

//删除指定位置的元素，原先index之后的元素均往前移动一位
public E remove(int index) ;

//移除此列表中首次出现的指定元素（如果存在）,此操作需要遍历数组
public boolean remove(Object o) {

以上介绍了ArrayList的增删等操作，下面再来看下源码

仔细观察我们会发现还有两个空数组

private static final Object[] EMPTY_ELEMENTDATA = {};

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

这两个空数组有什么用呢？我们再把上面的两个构造方法拿来看下：

public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

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

我们可以看到，当使用默认构造方法时，直接将DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值给了elementData，当使用指定容量进行构造ArrayList时，如果initialCapacity=0，将EMPTY_ELEMENTDATA赋值给了elementData，这两种方式构造出来的ArrayList初始容量均为0，那么为什么要使用两个不同的空数组呢？想知道答案我们来看下add(E e);方法：

public boolean add(E e) {
ensureCapacityInternal(size + 1);  // Increments modCount!!
elementData[size++] = e;
return true;
}

从上面代码可以看到，在add一个元素时，才对容量进行了操作，为什么要把扩容操作放在这里呢？其实是防止你new出一个数组，但是不用，导致空间资源的浪费。回到上面的问题，我们看下ensureCapacityInternal方法：

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

看下这里有个if判断，当elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA时，对容量有一个赋值操作，minCapacity为DEFAULT_CAPACITY与minCapacity的最大值。显然当第一次add元素时minCapacity==1所以初始容量就为DEFAULT_CAPACITY也就是10了。所以使用两个不同的空数组的原因就是为了保证：当我们使用默认构造方法对ArrayList进行构造时，初始容量为10。

　　下面再来看下ensureExplicitCapacity和grow方法：

private void ensureExplicitCapacity(int minCapacity) {
modCount++;
//当最小所需容量大于当前数组容量时进行grow操作
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}

private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//先尝试新容量为旧熔炼个的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}

　　可以看出，当最小所需容量大于当前数组容量时进行grow操作。先尝试新容量为旧熔炼个的1.5倍，如果还不够，那么就使用minCapacity作为当前扩充的容量大小。

　　此外有没有注意到ensureExplicitCapacity方法中有一个modCount++的操作，这个modCount是干什么用的呢？

　　

　　ArrayList的modCount是从类 java.util.AbstractList 继承的字段：

protected transient int modCount

这个字段代表已从结构上修改此列表的次数。从结构上修改是指更改列表的大小（也就是元素个数发生了变化），或者打乱列表，从而使正在进行的迭代产生错误的结果。

此字段由 iterator 和 listIterator 方法返回的迭代器和列表迭代器实现使用。如果意外更改了此字段中的值，则迭代器（或列表迭代器）将抛出 ConcurrentModificationException 来响应 next、remove、previous、set 或 add 操作。在迭代期间面临并发修改时，它提供了快速失败 行为，而不是非确定性行为。

大家可以测试下下面这段程序：

public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(10);
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
Integer integer = iterator.next();
if (integer == 10)
list.remove(integer);  //注意这个地方，此处换成list.add(integer)结果是一样的
}
}

上面这段代码会抛出如下异常：

Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
at java.util.ArrayList$Itr.next(ArrayList.java:851)
at Main.main(Main.java:12)

为何会报这个错？看下ArrayList的Iterator源码（有部分代码未贴出）：

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();
}
}

final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}

我们可以看到当做next()、remove()操作时，都要先checkForComodification()而这个方法做的事情就是判断modCount 与expectedModCount是否相等。不相等就报错。