ArrayList是一个什么东西？
ArrayList是数组列表，用来装载数据的容器，内部维护了一个变量名为elementData的object类型的数组（Object[]）。相比于LinkedList，具有查询速度较快，但插入删除较慢的特点，适合读多写少的场景，由于没有任何同步机制，所以在多线程场景下，存在线程安全的问题。
既然已经有了EMPTY_ELEMENTDATA属性，为什么还需要DEFAULTCAPACITY_EMPTY_ELEMENTDATA属性?
先看下声明：
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
这2个属性都是被private static final修饰，且都为空数组，那什么时候使用到呢？
当我们在使用ArrayList构造函数时指定容量为0时，new ArrayList(0)调用到的构造方法
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);
}
}
那么 elementData就会被赋值为EMPTY_ELEMENTDATA
如果使用默认的构造函数,new ArrayList()
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
elementData就会被赋值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA
赋值差异主要为了第一次添加元素的时候扩容策略
public boolean add(E e) {
//确保有足够的容量去储存元素
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(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方法里面，先判断elementData是否是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，如果是，扩容的大小为默认容量DEFAULT_CAPACITY=10，否则，扩容大小为1。
为什么属性elementData被修饰为transient?
transient Object[] elementData;
transient修饰的作用就是在默认的序列化中，被修饰的对象不会被序列到字节流中，ArrayList实现了readObject()和writeObject()方法，进行自定义的序列化。
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
在writeObject方法中先调用了默认的序列化方法，序列化了除elementData外的其他属性，接着遍历数组保存的元素，将他们序列化到字节流中。这样的处理保证了只序列化实际存储的那些元素，而不是整个数组，从而节省空间和时间。
为什么在writeObject方法里面还要手动序列化size属性？
这样写是出于兼容性考虑。
旧版本的JDK中，ArrayList的实现有所不同，会对size字段进行序列化。
而新版的JDK中，对优化了ArrayList的实现，不再序列化szie字段。
这个时候，如果去掉s.writeInt(size)，那么新版本JDK序列化的对象，在旧版本中就无法正确读取，因为缺少了size字段。
因此这种写法看起来多此一举，实际上却保证了兼容性。
ArrayList的扩容策略是怎样的？
1）首先判断需不需要扩容
当向ArrayList添加元素的时候，先计算所需最小容量=当前储存的元素数量+需要添加的元素数量，即minCapacity=size+n；若ArrayList是使用无参的构造方法生成的且是第一次添加元素，所需最小容量则取默认容量（DEFAULT_CAPACITY=10）与刚计算的最小容量的两者间的最大值，Math.max(DEFAULT_CAPACITY, minCapacity)
得到所需最小容量后，如果所需最小容量>elementData的数组的长度才需要进行扩容，否则不需要扩容操作。
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
//扩容方法
grow(minCapacity);
}
2）计算elementData实际扩容长度
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);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
定义实际扩容后的数组的长度为新容量newCapacity，比较当前数组长度的1.5倍newCapacity = oldCapacity + (oldCapacity >> 1)与所需的最小容量，取二者的最大值，当新容量大于MAX_ARRAY_SIZE （Integer.MAX_VALUE-8）时，需要进入hugeCapacity方法做进一步判断，所需最小容量溢出（大于Integer.MAX_VALUE）直接抛出OOM异常，如果所需最小容量大于MAX_ARRAY_SIZE，新容量则为Integer.MAX_VALUE，小于等于MAX_ARRAY_SIZE，新容量为MAX_ARRAY_SIZE。
总结
扩容一半，若还不够空间储存元素，则扩容后的长度为储存的元素个数。
3)扩容操作
创建长度为新容量newCapacity的数组，调用System.arrayCopy的native方法，将旧数组的所有元素拷贝到新数组中，将elementData指向新的数组引用。
**代码片段**
elementData = Arrays.copyOf(elementData, newCapacity);
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
