ArrayList
1，概念
ArrayList 是 List 接口的一个实现类，底层基于数组实现，具有查询快、增删慢；非线程安全，效率高的特点。同时，ArrayList 还具备了 List 接口的有序、可重复的特点，且允许插入空值。
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
2，源码分析
（如无特殊说明，我们一般取 JDK1.8 做分析）
我们主要看一下 ArrayList 的动态扩容机制：
2.1，基本属性
private static final int DEFAULT_CAPACITY = 10;//默认容量为 10
private static final Object[] EMPTY_ELEMENTDATA = {
}; //有参构造为 0 时的空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
};//无参构造时的空数组
transient Object[] elementData //不可序列化的对象数组
private int size; //实际元素个数
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; // 最大容量
2.2，构造方法
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);
}
}
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;
2.3，主要方法
我们主要讲一下 ArrayList 的动态扩容机制，此过程会涉及到主要方法的使用：
-
ArrayList 在使用无参构造器构造函数时，默认初始 elementData 为 0；当第一次添加
add 时，容量置为 10；之后若再次扩容，容量为 elementData 的 1.5 倍。
-
ArrayList 在使用有参构造器构造函数时，默认初始为 指定大小，再次扩容时以 elementData 的 1.5 倍进行扩容。
扩容机制的方法执行过程：
在执行元素添加时，size 初始为 0，即每次添加一个，容量也加一，非常节省空间！
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
ensureCapacityInternal 内部方法，以最省容量作为最小容量。可以看到空参构造时初始 elementData 为 0，所以第一次 add 时，最小容量便被置为 DEFAULT_CAPACITY 等于 10；
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
随后执行真正扩容逻辑 ensureExplicitCapacity，当且仅当最小容量（即实际长度）开始超过缓冲区长度时，执行第二次扩容机制 grow 方法；
private void ensureExplicitCapacity(int minCapacity) {
modCount++; //表示修改次数
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
首先取当前 elementData 的实际大小，然后执行newCapacity = oldCapacity + (oldCapacity >> 1)机制，使得新的数组容量为之前的（10 的）1.5 倍；
如果新的扩容容量仍然小于当前需要的最小容量，则当前最小容量为新的扩容容量；
如果新的扩容容量大于临界值，则进行大容量分配 hugeCapacity；
最终的扩容数组是基于当前数组和新的扩容容量的追加拷贝。
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);
}
如果想要的容量大于 MAX_ARRAY_SIZE，则分配 Integer.MAX_VALUE，否则分配 MAX_ARRAY_SIZE。其中：MAX.VALUE 为 0x7fffffff，转换成十进制就是 2147483647，也就是数组的最大长度是 2147483639
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
参考链接