简单介绍
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
ArrayList默认实现了java的序列化Serializable，意味着可以支持网络上的实体传输和本地硬盘相关的写入和读取。以下分析基于AndroidAPI25的源码
基本参数
/**
* 默认的初始化容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 默认的空数组实现
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 实际用于存储数据的数组
* 这里使用transient关键字是不希望进行默认的序列化操作
* ArrayList自己实现了readObject、
* writeObject等操作
*/
transient Object[] elementData;
/**
* ArrayList所容纳的当前数据的数量
*/
private int size;
构造方法
/**
* 指定数组的容量
* 一般在数量已经确定的情况下，推荐使用这种方式，可以将扩容的开销省去
*/
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
/**
* 默认指向一个空数组
*/
public ArrayList() {
super();
this.elementData = EMPTY_ELEMENTDATA;
}
/**
* 通过给定的Collection族类来构建对应的ArrayList
* 比方说Set（HaseSet之类）、List（LinkedList之类）等
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();//实际的开销在这里
size = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}
构造方法比较简单，一般来说根据具体的使用场景决定使用哪一种
1.大小确定，应该初始化容量
2.大小不确定，可以尝试在后期的时候动态处理
3.从其它Collection族类转为数组的方式存储，假设说是一个ArrayList的copy，这里默认使用的是System.arrayCopy，效率会相对自身for循环然后add的操作要好，所以推荐这种方式。
基础操作
public boolean add(E e) {
ensureCapacityInternal(size + 1);//确认容量，如果容量不足会进行扩容操作，这里是add的主要开销
elementData[size++] = e;//添加元素
return true;
}
接着看一下扩容的逻辑：
/**
* 这里是确认扩容容量的逻辑
* 实际上就是第一次扩容的时候，最小也是默认容量
* @param minCapacity 当前应该满足的最小容量
*/
private void ensureCapacityInternal(int minCapacity) {
//如果说new ArrayList()之类的空数组，那么第一次add操作的时候就会尝试扩容到默认大小
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//实际的扩容逻辑
ensureExplicitCapacity(minCapacity);
}
首先是处理实际的扩容容量，实际上ArrayList有一个默认的最小容量，这里也就是10。
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//
// overflow-conscious code
// 当前数组的大小是否满足需要的最小容量
// 不满足则扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// 旧的容量，这里注意因为有最小容量的限制，所以这里
int oldCapacity = elementData.length;
// 在旧的容量大小的基础上增加一半
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果扩容一半不满足的话，直接扩容到指定大小
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 因为newCapacity总是大于elementData.size，这里可以直接copy
elementData = Arrays.copyOf(elementData, newCapacity);
}
从这里可以看出，add的时候主要的开销是在扩容的Arrays.copyOf，所以说应该尽量避免扩容的出现，如果可以固定数量则最好指定数量。
接着看remove相关方法：
/**
* 移除指定位置的元素
* @param index 需要移除的元素下标0...(size-1)
* @return 被移除的元素
*/
public E remove(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
modCount++;
//先标记被删除的元素
E oldValue = (E) elementData[index];
//从数组移除某一个元素，如果不是末位的元素，那么在移除元素后面的元素都需要往前面移动一个位置
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//当前list大小减一，并且最后一个元素置空，尝试通过gc回收之前最后一个元素
elementData[--size] = null; // clear to let GC do its work
//返回被移除的元素
return oldValue;
}
/**
* 尝试移除指定的元素
* 从0开始遍历，只会移除第一个匹配的元素
* @param o 需要移除的元素
* @return true表示移除了指定的元素，false没有
*/
public boolean remove(Object o) {
if (o == null) {//如果传的为null
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {//通过equals匹配
fastRemove(index);
return true;
}
}
return false;
}
private void fastRemove(int index) {
modCount++;
//从数组移除某一个元素，如果不是末位的元素，那么在移除元素后面的元素都需要往前面移动一个位置
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//当前list大小减一，并且最后一个元素置空，尝试通过gc回收之前最后一个元素
elementData[--size] = null; // clear to let GC do its work
}
稍微总结一下，ArrayList的add和remove都会有一定的开销，添加的时候要考虑是否进行扩容，移除的时候要进行数组元素的移位，在这两方面来说就不如链表。
接着看一下元素的取出：
/**
* 通过下标获得指定的元素
* @param index 数组下标,0...(size-1)
* @return 对应位置的元素
*/
public E get(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
//可以看到只是从数组中获得对应元素
return (E) elementData[index];
}
相对于链表结构需要遍历的情况来说，这就是数组结构的优点，所以说一般要权衡添加删除和获取的频繁性，从而决定用不同的数据结构。
/**
* 在指定的位置添加一个元素
* 可能会导致部分元素后移
* @param index 需要添加的位置，0...size
* @param element 需要添加的元素
*/
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
//添加新元素必须先确保容量足够，否则扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//将当前位置的元素全部后移
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//添加当前元素
elementData[index] = element;
size++;
}
/**
* 在指定的位置上设置指定的元素
* 位置必须是当前的有效位置
* @param index 需要设置元素的下标位置，0...(size-1)
* @param element 需要设置的元素
* @return 被替换的元素
*/
public E set(int index, E element) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
E oldValue = (E) elementData[index];//标记被替换的元素
elementData[index] = element;//设置新的元素
return oldValue;
}
set(i,obj)操作是在当前已有数组的基础上替换元素，没有添加的作用，add(i,obj)操作会在指定位置添加一个元素，并且将后面的元素全部后移，支持在末尾添加元素。
/**
* 将大量元素添加到数组尾部
* @param c Collection的子类，需要添加的元素集
* @return true表示添加成功
*/
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();//Collection转换为数组
int numNew = a.length;//当前需要添加的数量
//确保容量满足添加的要求，否则进行扩容
ensureCapacityInternal(size + numNew);
//将新数组拷贝到数组尾部
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
/**
* 将大量元素从指定的位置开始添加的数组中
* 原来的元素向后移动
* @param index 指定的添加位置
* @param c Collection的子类，需要添加的元素集
* @return true表示添加成功
*/
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
//将当前添加位置后面的元素全部移动需要添加的元素数量个位置，从而腾出位置添加指定元素
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
//将当前需要添加的元素拷贝到指定的位置
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
一般来说添加大量数据通过addAll方式最为合适，不应该通过for循环然后add的形式，因为会造成重复的扩容和重复的数组拷贝操作。
/**
* 当前数组的容量
*/
public int size() {
return size;
}
/**
* 判断当前数组是否为空
* @return true表示当前数组为空，false不为空
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 判断当前数组是否包含指定的一个元素
* @return true表示包含，false不包含
*/
public boolean contains(Object o) {
//从0开始正序匹配
return indexOf(o) >= 0;
}
/**
* 查找指定的元素在数组中的位置
* 从0开始查找，只会匹配第一个满足的元素下标
* @param o 需要查找的元素
* @return 数组中的位置0...(size-1)
*/
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
/**
* 查找指定的元素在数组中的位置
* 倒序查找，只会匹配第一个满足的元素下标
* @param o 需要查找的元素
* @return 数组中的位置0...(size-1)
*/
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
/**
* 清空当前数组中的元素
*/
public void clear() {
modCount++;
// clear to let GC do its work
// 全部置空，尝试通过gc进行回收
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;//标记当前数组中元素数量为0
}
总结
ArrayList是基于数组结构实现的一个列表，那么优点就是获取指定位置的数据，缺点就是在添加和删除数据时候会有一定的开销。
个人推荐ArrayList在使用的过程中尽量使用原生提供的API操作，更多的操作可以结合Collections工具类进行（排序之类的）
最后注意一下ArrayList并不是线程安全的，所以并不太适合并发操作，如果要用的话需要手动加锁
