目录
引言
在Java中，ArrayList是最常用的集合之一。它是一种容器，它的内部定义了一个
Object类型
的数组
elementData
，因此可用于存储任意类型的数据。我们知道，数组是长度恒定的。而ArrayList相当于是一个长度可变的动态数组，一起来看看的它的扩容机制。
源代码
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
......
private int size;
private static final Object[] EMPTY_ELEMENTDATA = {};
//定义的空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData; // non-private to simplify nested class access
//无参的构造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
......
//有参构造方法
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);
}
}
......
}
如果使用无参的构造方法创造一个ArrayList集合对象，那么就
默
认
让这个数组指向一个空数组
DEFAULTCAPACITY_EMPTY_ELEMENTDATA
；它是一个私有的，静态的常量。也就是只要是通过无参构造方法创建ArrayList对象，无论创建多少个，每个ArrayList内部的elementData都指向那个空数组，没有重新new，这一点也节省了内存空间！
如果使用有参的构造方法，就会根据传入的长度，创建出新的Object[]类型数组，并让
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;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
ArrayList内部定义了一个
私有变量size
，它时刻
记录着当前集合存储的元素个数
。使用add()方法添加元素时：
1.调用
ensureCapacityInternal(int minCapacity )
方法传入“
size+1”(最小容量)
看是否需要扩容，
2.在ensureCapacityInternal(int minCapacity )方法内，调用
calculateCapacity(Object[] elementData, int minCapacity)
将
elementData
和”
最小容量
“传入,
3.在calculateCapacity(Object[] elementData, int minCapacity)方法内， 判断
elementData
是不是
默认的空数组
，如果是，就返回
默认容量DEFAULT_CAPACITY（10）
和
最小容量minCapacity
中较大的值，否则返回
最小容量minCapacity
。记这个值为
value
4.当ensureExplicitCapacity()方法拿到这个值
value
, 就用它减去原数组elementData的长度 看是否大于0（原数组elementData容量不够），如果大于0，就调用grow()方法进行扩容。
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;
}
5.在grow()方法中，按照
oldCapacity + (oldCapacity >> 1）
进行计算新的容量
newCapacity
，相当于是计算
原数组的1.5倍容量
。如果这个容量比最小容量要小，那么newCapacity就重新赋值为minCapacity。如果最小容量minCapacity比默认的容量MAX_ARRAY_SIZE还要大，就会调用hugeCapacity(int minCapacity)方法，最后得到
Inteter.MAX_VALUE或Integer.MAX_VALUE-8
，然后通过Arrays.copyOf()方法创建出新的数组，并将原来数组的值复制至新的数组中。
总结
1.如果使用无参构造方法创建ArrayList对象，那么在第一次添加元素时就会扩容为10，当要添加第11个元素时 ，按照1.5倍进行扩容。往后但凡超过数组容量，都按照1.5倍进行扩容。然后按照新容量创建出数组，将原数组内容复制至新数组。同时elementData指向新数组。
2.如果是有有参的构造方法创建ArrayList对象，那么当添加元素至超过elementData容量时，按照原数组1.5倍容量进行扩容。
3.ArrayList的最大容量为 Inteter.MAX_VALUE或Integer.MAX_VALUE-8;
4.在使用ArrayLIst之前，可以先估计要存储元素的个数。使用有参构造方法创建对象，这样可以减少扩容次数，减少内存开销。