深入理解Java集合框架系列 -第七章 ArrayList
ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。
1、ArrayList的实现的接口和继承的抽象类
JDK源码如下：
publicclassArrayList<E>extends AbstractList<E>implements List<E>,RandomAccess, Cloneable, java.io.Serializable{}。从源码可以看出它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。
ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是Java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象,这就是快速随机访问。
ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。
2、ArrayList包含了两个重要的对象
ArrayList包含了两个重要的对象：elementData 和 size；size则是动态数组的实际大小。elementData 是"Object[]类型的数组"，它保存了添加到ArrayList中的元素。实际上，elementData是个动态数组，我们能通过构造函数 ArrayList(int initialCapacity)来执行它的初始容量为initialCapacity；如果通过不含参数的构造函数ArrayList()来创建ArrayList，则elementData的容量默认是10。
/**
* Default initial capacity.
*/
private static final intDEFAULT_CAPACITY = 10;
elementData数组的大小会根据ArrayList容量的增长而动态的增长，具体的增长方式，请参考源码分析中的ensureCapacity()函数。比如JDK1.8版本的是原来的容量的3倍，增长了两倍。
/**
* Increases the capacity to ensure that itcan hold at least the
* number of elements specified by theminimum capacity argument.
* @param minCapacity thedesired minimum capacity
*/
privatevoid grow(int minCapacity) {
// overflow-consciouscode
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 isusually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
扩容结束后，调用了Arrays.copyOf(elementData,newCapacity)方法，这个方法中先创建了一个新的容量为newCapacity的对象数组，然后使用System.arraycopy()方法将旧的对象数组复制到新的对象数组中。新数组大小为原来的3倍，arraycopy 为System类中的native方法，有比较大的性能开销，所以在我们使用ArrayList时，最好能预计数据的数量并在第一次创建时就申请够内存，否则建议使用LinkedList。
3、ArrayList属性和方法
4、ArrayList特点
ArrayList数组线性表的特点为:类似数组的形式进行存储，因此它的随机访问速度极快。
ArrayList数组线性表的缺点为:不适合于在线性表中间需要频繁进行插入和删除操作。因为每次插入和删除都需要移动数组中的元素
5、ArrayList是线程不安全的
和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。
ArrayList线程不安全的例子：
import java.util.ArrayList;
import java.util.List;
importjava.util.Vector;
publicclass ArrayListNoThreadSafe {
privatestatic List<Integer>list = newArrayList<Integer>();
// private staticList<Integer> list = new Vector<Integer>();
publicstaticvoid main(String[] args) {
for (int i=0; i<1000; i++){
list.add(i);
}
for(int i=0;i<100;i++){
new Thread(){
@Override
publicvoid run(){
for (int i=0; i<100; i++)
list.remove(0);
}
}.start();
new Thread(){
@Override
publicvoid run(){
for (int i=0; i<100; i++)
list.add(10*i + i);
}
}.start();
}
try {
Thread.sleep(1000);
} catch (InterruptedExceptione) {};
System.out.println(list.size());
}
}
执行的结果应该等于1000，如果大于或者小于1000，就是线程不安全。如果改为vector始终是1000，所以vector是线程安全的。
fail-fast 机制是Java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。例如：当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。在详细介绍fail-fast机制的原理之前，先通过一个示例来认识fail-fast。
示范源代码：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
importjava.util.concurrent.CopyOnWriteArrayList;
publicclass FastFailTest {
privatestatic List<String>list = newArrayList<String>();
//private staticList<String> list = new CopyOnWriteArrayList<String>();
publicstaticvoid main(String[] args) {
// 同时启动两个线程对list进行操作！
new ThreadOne().start();
new ThreadTwo().start();
}
privatestaticvoid printAll() {
String value = null;
Iterator<String> iter = list.iterator();
while(iter.hasNext()) {
value = (String)iter.next();
System.out.print(value+", ");
}
}
/**
* 向list中依次添加0,1,2,3,4,5，每添加一个数之后，就通过printAll()遍历整个list
*/
privatestaticclass ThreadOne extends Thread {
publicvoid run() {
int i = 0;
while (i<6) {
list.add(String.valueOf(i));
printAll();
i++;
}
}
}
/**
* 向list中依次添加10,11,12,13,14,15，每添加一个数之后，就通过printAll()遍历整个list
*/
privatestaticclass ThreadTwo extends Thread {
publicvoid run() {
int i = 10;
while (i<16) {
list.add(String.valueOf(i));
printAll();
i++;
}
}
}
}
运行结果：
运行该代码，抛出异常java.util.ConcurrentModificationException！即，产生fail-fast事件！
结果说明：
(01) FastFailTest中通过 new ThreadOne().start() 和 new ThreadTwo().start() 同时启动两个线程去操作list。ThreadOne线程：向list中依次添加0,1,2,3,4,5。每添加一个数之后，就通过printAll()遍历整个list。ThreadTwo线程：向list中依次添加10,11,12,13,14,15。每添加一个数之后，就通过printAll()遍历整个list。
(02) 当某一个线程遍历list的过程中，list的内容被另外一个线程所改变了；就会抛出ConcurrentModificationException异常，产生fail-fast事件。
fail-fast解决办法
fail-fast机制，是一种错误检测机制。它只能被用来检测错误，因为JDK并不保证fail-fast机制一定会发生。若在多线程环境下使用fail-fast机制的集合，建议使用“java.util.concurrent包下的类”去取代“java.util包下的类”。
所以，本例中只需要将ArrayList替换成java.util.concurrent包下对应的类即可。
fail-fast原理
产生fail-fast事件，是通过抛出ConcurrentModificationException异常来触发的。
那么，ArrayList是如何抛出ConcurrentModificationException异常的呢?
我们可以发现在调用 next() 和 remove()时，都会执行 checkForComodification()。若 “modCount 不等于 expectedModCount”，则抛出ConcurrentModificationException异常，产生fail-fast事件。无论是add()、remove()，还是clear()，只要涉及到修改集合中的元素个数时，都会改变modCount的值。
接下来，我们再系统的梳理一下fail-fast是怎么产生的。步骤如下：
(01) 新建了一个ArrayList，名称为arrayList。
(02) 向arrayList中添加内容。
(03) 新建一个“线程a”，并在“线程a”中通过Iterator反复的读取arrayList的值。
(04) 新建一个“线程b”，在“线程b”中删除arrayList中的一个“节点A”。
(05) 这时，就会产生有趣的事件了。
在某一时刻，“线程a”创建了arrayList的Iterator。此时“节点A”仍然存在于arrayList中，创建arrayList时，expectedModCount = modCount(假设它们此时的值为N)。在“线程a”在遍历arrayList过程中的某一时刻，“线程b”执行了，并且“线程b”删除了arrayList中的“节点A”。“线程b”执行remove()进行删除操作时，在remove()中执行了“modCount++”，此时modCount变成了N+1！，“线程a”接着遍历，当它执行到next()函数时，调用checkForComodification()比较“expectedModCount”和“modCount”的大小；而“expectedModCount=N”，“modCount=N+1”,这样，便抛出ConcurrentModificationException异常，产生fail-fast事件。至此，我们就完全了解了fail-fast是如何产生的！即，当多个线程对同一个集合进行操作的时候，某线程访问集合的过程中，该集合的内容被其他线程所改变(即其它线程通过add、remove、clear等方法，改变了modCount的值)；这时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。