ArrayList
ArrayList简介
ArrayList底层是数组队列，与普通数据的区别在于容量能动态增长。ArrayList继承了AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable接口。
- AbstractList抽象类：实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能；
- RandomAccess接口：标明这个接口的List集合是支持快速随机访问（快速随机访问即我们可以通过元素的序号快速获取元素对象）
- Cloneable接口：覆盖了clone方法，能被克隆
- Serializable接口：支持序列化，能通过序列化去传输
ArrayList不是线程安全类，因此在多线程中不建议使用ArrayList，而是Vector。
ArrayList源码
构造函数
/**
* 默认初始化容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 默认的空数组实例
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 默认的空数组实例
* 和EMPTY_ELEMENTDATA主要的区别在于：添加首个元素的时候判断是否需要初始化容量，详见：calculateCapacity方法
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 存放数据
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* 带初始化容量参数的构造函数
*/
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() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 构造包含Collection元素的列表，集合元素通过集合的迭代器按顺序返回
* 如果指定集合为null，报错NullPointerException
*/
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时，实际上初始化赋值的是一个空数组。只有当真正对数组进行添加元素操作时，才真正分配容量（数组容量扩为10）。
ArrayList扩容机制
以无参构造函数创建的ArrayList为例进行分析
add方法
/**
* 往集合尾部添加元素
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
ensureCapacityInternal方法
/**
* 扩容
*/
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/**
* 计算容量大小，返回最少需要的容量大小
* 如果是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则根据初始化容量大小（10）来进行判断
*/
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);
}
grow方法
/**
* 最大可分配的数组大小
* 超出此范围报错：OutOfMemoryError
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 增加数组容量
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
// >> 移位运算符：>> 1 右移一位相当于除2，右移n位相当于除以2的n次方，移位运算只需要一次寻址，更快
// 因此每次扩容之后的容量就为原来的1.5倍！
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);
}
序列化
/**
* 数据存放
*/
transient Object[] elementData; // non-private to simplify nested class access
源码中，发现存储元素的数据用transient进行修饰，即elementData默认不会被序列化。那如果进行序列化之后，数据不就完全丢失了吗？
因此我们来看一下readObject和writeObject源码。
readObject
/**
* Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
* deserialize it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in capacity
s.readInt(); // ignored
if (size > 0) {
// be like clone(), allocate array based upon size not capacity
int capacity = calculateCapacity(elementData, size);
SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
writeObject
/**
* Save the state of the <tt>ArrayList</tt> instance to a stream (that
* is, serialize it).
*
* @serialData The length of the array backing the <tt>ArrayList</tt>
* instance is emitted (int), followed by all of its elements
* (each an <tt>Object</tt>) in the proper order.
*/
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();
}
}
ArrayList在序列化的时候会调用writeObject，直接将size和element写入ObjectOutputStream；反序列化的时候调用readObject，从ObjectInputStream获取size和element，再恢复到elementData。
ArrayList不直接用elementData进行序列化，主要是因为elementData是个缓存数组，会预留一些容量，通过writeObject的操作来实现序列化，就可以保证只序列化实际存储的元素，而不是整个数组。节省空间和时间。
ensureCapacity方法
ArrayList提供ensureCapacity方法，用于减少增量重新分配的次数。
我们做个模拟demo看看效果
public static void main(String[] args) {
ArrayList<Object> list = new ArrayList<Object>();
final int N = 10000000;
long startTime = System.currentTimeMillis();
for (int i = 0; i < N; i++) {
list.add(i);
}
long endTime = System.currentTimeMillis();
System.out.println("使用ensureCapacity方法前："+(endTime - startTime));
list = new ArrayList<Object>();
long startTime1 = System.currentTimeMillis();
list.ensureCapacity(N);
for (int i = 0; i < N; i++) {
list.add(i);
}
long endTime1 = System.currentTimeMillis();
System.out.println("使用ensureCapacity方法后："+(endTime1 - startTime1));
}
让我们一起看一下结果：
使用ensureCapacity方法前：2409
使用ensureCapacity方法后：384
通过运行结果，我们可以很明显的看出向 ArrayList 添加大量元素之前最好先使用ensureCapacity 方法，以减少增量重新分配的次数，提高性能。
