ArrayList的扩容问题
这里就要从ArrayList的源码说起。
ArrayList类的定义
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
从ArrayList类的定义可以看出，ArrayList继承了AbstractList并且实现了List，是一个数组队列，具有增、删、改、遍历等基本功能。
AbstractList还实现了RandomAccess接口，及RandomAccess可以进行随机访问。
什么是随机访问？
我理解的随机访问就是可以根据ArrayList元素下标获取元素。
ArrayList实现了Cloneable接口，可以被克隆。
ArrayList实现了java.io.Serializable接口，即ArrayList支持序列化，可通过序列化进行传输。
关于线程安全问题！！
ArrayList是线程不安全的集合，在多线程环境中，可使用线程安全的Vector或者CopyOnWriteArrayList（这里建议使用CopyOnWriteArrayList）。
ArrayList源码中的属性
// ArrayList的额序列化版本号
private static final long serialVersionUID = 8683452581122892189L;
// ArrayList的默认容量为10
private static final int DEFAULT_CAPACITY = 10;
// 空的对象数组
private static final Object[] EMPTY_ELEMENTDATA = {};
// 空的对象数组，当调用ArrayList的无参构造器时使用。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// ArrayList存放数据的数组
transient Object[] elementData;
// ArrayList中的数据个数（与容量不同）
private int size;
从ArrayList的属性可以看出，ArrayList底层其实是一个动态数组，他与数组最大的区别就是ArrayList可以动态的扩容。ArrayList的扩容问题会在本文分析到。
ArrayList的构造函数
ArrayList有三个构造函数
指定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);
}
}
从构造函数中不难看出，若传入的参数initialCapacity<0会抛出异常，当initialCapacity==0时，将ArrayList属性中的EMPTY_ELEMENTDATA赋值给elementData，这时，ArrayList底层其实就是一个空的容量为0数组队列。当initialCapacity>0会创建一个容量为initialCapacity大小的对象数组。
无参构造器
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
ArrayList的无参构造函数内容很简单，就是讲ArrayList类属性中的DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值给elementData，通过ArrayList的无参构造函数可以得到一个空的长度为0的数组队列。
参数为Collection的构造器
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
构造器首先调用Collection对象c的toArray方法，将对象c转换为Object数组并赋值为elementData。ArrayList便初始化。
那么，ArrayList的初始容量为什么为10呢？ArrayList类中的DEFAULT_CAPACITY属性又在哪里被使用？接下来说到的ArrayList的扩容问题会解释道ArrayList的初始容量问题和DEFAULT_CAPACITY的使用。
ArrayList的扩容问题可以从ArrayList的add方法说起。
ArrayList的add方法有两个：
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
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++;
}
这里通过讲解第一个add方法分析ArrayList的扩容问题。
当通过使用add(E e)方法向集合中添加数据时，会先调用ensureCapacityInternal(size + 1);方法，
我们假设当前集合size==0，即空集合。
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
ensureCapacityInternal(int minCapacity)中minCapacity参数为size+1即参数为1，ensureCapacityInternal方法再调用ensureExplicitCapacity(int minCapacity)方法。
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
而ensureExplicitCapacity(int minCapacity)方法的参数minCapacity为
calculateCapacity(elementData, minCapacity)方法的返回值。
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
所以我们要先分析calculateCapacity方法，calculateCapacity方法传入elementData, minCapacity，这里minCapacity的值认为size+1为1，if判断条件成立，执行return Math.max(DEFAULT_CAPACITY, minCapacity);返回的便是DEFAULT_CAPACITY，即返回10。然后将返回的10作为ensureExplicitCapacity方法的参数，那么ensureExplicitCapacity方法的参数为10。
ensureExplicitCapacity方法中的if判断成立，调用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);
}
方法内部int oldCapacity = elementData.length，则oldCapacity ==0
这里涉及到位运算，>>1这里可以大致理解为扩大为原本的1.5倍，
那么 int newCapacity = oldCapacity + (oldCapacity >> 1)，则newCapacity ==0，
则第一个if判断条件成立，newCapacity = minCapacity，newCapacity ==10。
最后执行elementData = Arrays.copyOf(elementData, newCapacity);，则elementData 被扩容为容量为10的对象数组。
至此，ArrayList的扩容到此结束，继续回到add(E e)方法，执行elementData[size++] = e;语句，将e放入
elementData 对象数组中。
扩容问题总结
这里笔者以刚被初始化的ArrayList集合，即size==0的的情况分析了ArrayList集合的扩容问题，只是为了展示ArrayList的扩容全过程，大家可以通过不同的size进行不同的分析，充分理解ArrayList的扩容过程。
这里值得一提的是，ArrayList默认初始容量（调用无参构造器创建的ArrayList对象）并不是10，而是0，当第一次放入数据时，ArrayList的容量会被扩容到10。
ArrayList的其它方法包括被重载的add方法就不再过多分析，大家理解了上述问题后，其它方法便会无师自通。
