说明：本次ArrayList的源码阅读是基于 jdk1.8
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;
/**
* Default initial capacity. 默认初始容量 = 10
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 如果容量为0的时候，就返回这个数组
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
* 使用默认容量 10 的时候，使用这个数组
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.
* list 真正存储数据的地方
*/
transient Object[] elementData; // non-private to simplify nested class access
//修改次数
protected transient int modCount = 0;
/**
* 数组长度 即 list的长度 * The size of the ArrayList (the number of elements it contains) */ private int size;
// 无参构造函数：空数组
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//有参构造 initialCapacity 初始容量
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);
}
//参数为 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;
}
}
}
ArrayList有三个构造方法，不同的构造方法的容量是不一样的，具体可以查看JDK 源码。
- 如果不传入初始容量，就使用默认容量，并设置
elementData为DEFAULTCAPACITY_EMPTY_ELEMENTDATA - 如果传入初始容量，会判断这个传入的值，如果大于0，就new一个新的Object数组，如果等于0，就直接设置
elementData为EMPTY_ELEMENTDATA。 - 如果传入一个Collection，则会调用
toArray()方法把它变成一个数组并赋值给elementData。同样会判断它的长度是否为0，如果为0，设置elementData为EMPTY_ELEMENTDATA
ArrayList的 add、remove、set、get实际上是对数组的操作；真正 有 特殊的操作是 add方法，add方法可能涉及到 数组的扩容
什么是扩容？
ArrayList有 2个概念，DEFAULT_CAPACITY 初始容量，其实质是数组elementData的长度。而size则表示的“存放的元素的个数”。
ArrayList的add 方法：
public boolean add(E e) {
//执行新增逻辑
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
// 如果 此时的list数组 elementData 是空数组，求 要扩容后的 数组的长度 minCapacity 为 默认容量和 minCapacity中的最大值
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//执行
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
// 如果此时 加1后的数组长度 大于 此时 elementData数组的 长度，执行 扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length; //原数组的容量
int newCapacity = oldCapacity + (oldCapacity >> 1);// 扩容为原来容量的1.5倍 ，>> 右位移运算符，把符号左边的数据除以2的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);//数组扩容 }
// 处理数组最大值， 防止数组下标越界， 最大值为 Integer.MAX_VALUE private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }
可以看到，底层其实是调用了Arrays.copyOf方法来进行扩充数组容量的。这里我们主要看一下最后一个方法newCapacity(int minCapacity)的实现。
默认情况下，新的容量会是原容量的1.5倍，这里用了位运算提高效率。一般情况下，如果扩容1.5倍后就大于期望容量，那就返回这个1.5倍旧容量的值。而如果小于期望容量，那就返回期望容量。这里对默认容量10做了特殊处理。
使用1.5倍这个数值而不是直接使用期望容量，是为了防止频繁扩容影响性能。试想如果每次add操作都要扩容一次，那性能将会非常低下。
常见问题汇总
- ArrayList的默认初始长度是多少？最大长度是多少？
ArrayList的默认初始长度是10，是由DEFAULT_CAPACITY设定的。
由于ArrayList底层是用Object数组存储元素，所以ArrayList最大长度为Integer.MAX_VALUE，即2147483647(2)。这里需要注意常量MAX_ARRAY_SIZE(Integer.MAX_VALUE - 8)并不是ArrayList真正的最大长度，原因可以参考hugeCapacity()方法。
ArrayList是如何扩容的？
- 扩容发生在插入数组元素时（关键方法为grow()方法）
先计算增加完新元素后的ArrayList长度size
然后size与minCapacity比较来判断是否需要扩容
扩容时一般扩容为新数组长度newCapacity为原数组长度oldCapacity的1.5倍（oldCapacity带符号右移1位并加上oldCapacity）。
特殊情况是存在newCapacity长度超过Array的最大支持长度MAX_ARRAY_SIZE则调用hugeCapacity()进行特殊处理防止数组超出最大长度(int最大值)。
- ArrayList扩容后是否会自动缩容？如果不能怎样进行缩容？
ArrayList只能自动扩容，不能自动缩容。如果需要进行缩容，可以调用ArrayList提供的trimToSize()方法。调用remove方法，删除元素的时候，不会进行 缩容操作，只进行数组的copy操作，空余出来的位置为null;
- ArrayList底层数组扩容时是如何保证高效复制数组的？
表面上是调用Arrays.copyOf()方法，实际上是Arrays.copyOf()通过调用System.arraycopy()方法确保高效复制数组。