ArrayList
ArrayList简介
ArrayList底层是数组队列，与普通数据的区别在于容量能动态增长。ArrayList继承了AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable接口。
- AbstractList抽象类：实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能；
- RandomAccess接口：表明这个接口的List集合是支持快速随机访问（快速随机访问即我们可以通过元素的序号快速获取元素对象）
- Cloneable接口：覆盖了clone方法，能被克隆
- Serializable接口：支持序列化，能通过序列化去传输
ArrayList不是线程安全类，因此在多线程中不建议使用ArrayList，而是Vector。
ArrayList源码
构造函数
<code>/** * 默认初始化容量 */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; }}/<code> 注：以无参数构造方法创建ArrayList时，实际上初始化赋值的是一个空数组。只有当真正对数组进行添加元素操作时，才真正分配容量（数组容量扩为10）。
ArrayList扩容机制
以无参构造函数创建的ArrayList为例进行分析
- add方法
<code>/** * 往集合尾部添加元素 */public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true;}/<code>- ensureCapacityInternal方法
<code>/** * 扩容 */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);}/<code>- grow方法
<code>/** * 最大可分配的数组大小 * 超出此范围报错：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);}/<code> 序列化
<code>/** * 数据存放 */transient Object[] elementData; // non-private to simplify nested class access/<code>
源码中，发现存储元素的数据用transient进行修饰，即elementData默认不会被序列化。那如果进行序列化之后，数据不就完全丢失了吗？
因此我们来看一下readObject和writeObject源码。
- readObject
<code>/** * Reconstitute the ArrayList 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>/<code>- writeObject
<code>/** * Save the state of the ArrayList instance to a stream (that * is, serialize it). * * @serialData The length of the array backing the ArrayList * instance is emitted (int), followed by all of its elements * (each an Object) 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>/<code>ArrayList在序列化的时候会调用writeObject，直接将size和element写入ObjectOutputStream；反序列化的时候调用readObject，从ObjectInputStream获取size和element，再恢复到elementData。
ArrayList不直接用elementData进行序列化，主要是因为elementData是个缓存数组，会预留一些容量，通过writeObject的操作来实现序列化，就可以保证只序列化实际存储的元素，而不是整个数组。节省空间和时间。
ensureCapacity方法
ArrayList提供ensureCapacity方法，用于减少增量重新分配的次数。
我们做个模拟demo看看效果
<code>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));}/<object>/<object>/<object>/<code>让我们一起看一下结果：
<code>使用ensureCapacity方法前：2409使用ensureCapacity方法后：384/<code>
通过运行结果，我们可以很明显的看出向 ArrayList 添加大量元素之前最好先使用ensureCapacity 方法，以减少增量重新分配的次数，提高性能。
分享到:
閱讀更多 陳先森筆記 的文章
關鍵字: 序列化 源码 minCapacity
