Arraylist 主要构造函数
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);
}
}
/**
* Constructs an empty list with an initial capacity of ten.
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}如果传入参数为0，则创建一个空的对象数组
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
否则创建一个Object［n］的数组，注意是开辟空间，不是往里面填写值，所以在没有add之前，size一直为缺省值0
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
} private void ensureCapacityInternal(int 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 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);
}其中size＋1（minCapacity）为真实长度，与10比较取大值，这里记为Aprivate static final int DEFAULT_CAPACITY = 10;
如果A比ementData.length大，则进行空间再分配，进入grow，这是第一步，确定是否要再分配
小结一下：如果 size＋1（初始首次为10）比现有数组长度大，则决定重新分配空间，然后解决第二个问题，分配多少空间
int newCapacity = oldCapacity + (oldCapacity >> 1);
这里重新分配的空间长度取newCapacity（右移X位就是除以2的X次方的整数部分，大约是length大约为1.5倍）与A的大值，一般情况下（只add一个对象），A为length＋1，所以一边情况下（只add一个对象），重新分配的空间为
elementData.length + elementData.length>>1 大约是原长度的1.45倍
小结一下，在只add一个对象的情况下，重新分配的长度为 （1.45～1.5）L，L＋1，10的最大值 记录L为原数组长度
结论：
ArrayList add 单个对象两个关键点：
1.是否重新分配，
首次：分配（max（10，1）>0）
其它：当size＋1 > L 时，重分配
2.分配多少空间，
首次：10（max（10，1）＝10）
其它：取（1.45～1.5）L（L>=10, so L＋1可忽略）
ArrayList add 对象集合两个关键点：
1.是否重新分配，
首次：分配（max（10，n）>0）
其它：当size＋n > L 时，重分配
2.分配多少空间，
首次：10，n的大值
其它：取（1.45～1.5）L，L＋n的大值
再抽象：（仅考虑默认构造函数）
首次
1.是否重新分配
分配
2.分配多少空间
max（10，n），n为add时的集合长度
其它
1.是否重新分配
当 size＋n > L 时，重分配 （L>＝10－因为首次分配至少10）
2.分配多少空间
取max｛（1.45～1.5）L，L＋n ｝（L>＝10）
顺便提一下：
ArrayList基于数组，LinkedList基于链表
ArrayList，增、删 慢 查、改快
LinkedList，增、删 相对快快 查、改相对慢
此外，LinkedList实现了Queue接口，可以作为队列使用
另Vector非常类似ArrayList，采用数组方式储存，但是Vector是同步的。
由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。