ArrayList特点：
ArrayList方法实现：
扩容方法的实现：
源码：
private void ensureCapacityInternal(int minCapacity) {
//如果数组为默认大小，则扩大的容量为minCapacity和默认值两个值的较大者
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
//如果要扩大的容量比当前的数组长度大，则对数组进行扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//增加的容量为原来大小的一半
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果增加了一半的容量还比要扩容的数量小，则新数组的大小为要扩容的数量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//如果新数组的大小大于Integer.MAX_VALUE - 8，则进行判断
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) {
//如果minCapacity < 0,则容量值溢出
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;//Integer.MAX_VALUE - 8
}
clone方法分析：
ArrayList中的clone()方法为浅克隆，克隆后的集合对象与原有的集合对象不是同一个对象（即，指向不同的内存空间），但是它们集合元素引用的对象都是相同的。
源码：
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) 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(e);
}
}
示例程序：
ArrayList<String> list = new ArrayList<>();
//这样加入集合中时，引用的对象在常量池中
// list.add("dongfangbubai");
// String string = "dongfangbubai";
////这样加入集合中时，引用的对象堆中
String string = new String("dongfangbubai");
list.add(string);
list.add("shangshanruoshui"); ArrayList listClone = (ArrayList) list.clone();
System.out.println(listClone); String content = "dongfangbubai"; System.out.println(list.get(0).equals(content));
System.out.println(list.get(0) == content);
//克隆前后两个集合对应的元素所引用的都是同一个对象，true
System.out.println(list.get(0) == listClone.get(0));
//克隆前后两个集合是不同的集合，false
System.out.println(list == listClone);
ArrayList迭代时用迭代器只能一次删除一个元素（在一个迭代循环里），否则会出现java.lang.IllegalStateException异常。从源码可以看出这一点。
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
//进行一次删除操作时，随即就把lastRet置为一，每次迭代时就把迭代的元素索引赋个给astRet
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
// 数据结构发生改变，和fail-fast机制有关，在使用迭代器过程中，只能通过迭代器的方法（比如迭代器中add，remove等），修改List的数据结构， // 如果使用List的方法（比如List中的add，remove等），修改List的数据结构，会抛出ConcurrentModificationException
fail-fast机制的实现
fail-fast机制也叫作”快速失败”机制，是java集合中的一种错误检测机制。
在对集合进行迭代过程中，除了迭代器可以对集合进行数据结构上进行修改（迭代器进行结构修改时不会增加modCount值），其他的对集合的数据结构进行修改，都会抛出ConcurrentModificationException错误。
这里，所谓的进行数据结构上进行修改,是指对存储的对象，进行add,set,remove操作，进而对数据发生改变。
ArrayList中，有个modCount的变量，每次进行add，set，remove等操作，都会执行modCount++。
在获取ArrayList的迭代器时，会将ArrayList中的modCount保存在迭代中，
每次执行add,set,remove等操作，都会执行一次检查，调用checkForComodification方法，对modCount进行比较。
如果迭代器中的modCount和List中的modCount不同，则抛出ConcurrentModificationException
源码：源码中modCount在list中，
expectedModCount是在迭代时传入的modCount值，若迭代过程中list结构改变时，modCount会增加，以此迭代器1来判断迭代时list是否变化。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
ArrayList与vector比较：