前言
上一篇文章主要介绍了下容器类，这篇文章将深入浅出地学习ArrayList。
ArrayList的简要介绍
ArrayList基于数组实现，无容量限制，在执行插入元素时可能要扩容，在删除元素时并不会减小容量，在查找元素时要遍历数组，对于非null的元素采取equals的方式寻找，非线程安全。优缺点：查找快，插入删除效率低。
此图由IDEA生成，由图可得出其继承关系，分别是继承自AbstractList抽象类，实现了List、RandomAccess、Cloneable和Serializable接口。
从源码分析ArrayList
成员变量
private static final int DEFAULT_CAPACITY = 10;//默认大小为10
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData;
private int size;//容器内的元素数量
private static final long serialVersionUID = 8683452581122892189L;
构造方法
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;
}
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;
}
}
三种构造方法，传入初始容量大小，若无则使用默认值10作为初始容量，若传入集合则将其toArray再导入ArrayList。
添加
从一个添加方法来看添加操作：
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
可以看到添加时会进行ensureCapacity操作，在构造时即使传入小于10的正整数在第一次添加元素时也会使用默认大小10作为初始容量大小。 以下是其他的添加方法。
boolean add(E e);//将指定的元素追加到此列表的末尾。
void add(int index, E element);//在此列表中的指定位置插入指定的元素。
boolean addAll(Collection<? extends E> c);//按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
boolean addAll(int index, Collection<? extends E> c);//将指定集合中的所有元素插入到此列表中，从指定的位置开始。
删除
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
删除指定下标的元素，删除时不会减小容量，删除指定下标的元素后，后面的元素使用arraycopy连接起来。下面是其他的删除方法。
E remove(int index);//删除该列表中指定位置的元素。
boolean remove(Object o);//从列表中删除指定元素的第一个出现（如果存在）。
boolean removeAll(Collection<?> c);//从此列表中删除指定集合中包含的所有元素。
boolean removeIf(Predicate<? super E> filter);//删除满足给定谓词的此集合的所有元素。
protected void removeRange(int fromIndex, int toIndex);//从这个列表中删除所有索引在 fromIndex （含）和 toIndex之间的元素。
void clear();//从列表中删除所有元素。
扩容机制
前面添加操作时有提到ensureCapacity，原因是在添加时有可能当前容器已经满了需要扩容，下面来从源码看看扩容机制。
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);
}
可以看到扩容是新容量等于旧容量加旧容量右移1位（除以2），即1.5倍进行扩容。如果1.5倍不能满足容量需求，那就用满足需求的最小容量。
更新和查询
E get(int index);//返回此列表中指定位置的元素。
E set(int index, E element);//用指定的元素替换此列表中指定位置的元素。
这个就比较简单了，get和set，不过要注意下有rangeCheck确保边界。
遍历
简单说下三种遍历方式
//迭代器
Iterator it = arrayList1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//for循环遍历
for(int i=0;i<arrayList1.size();i++){
System.out.println(arrayList1.get(i));
}
//增强for循环
for(String str:arrayList1){
System.out.println(str);
}
其他方法和注意点
boolean contains(Object o);//如果此列表包含指定的元素，则返回 true 。
int indexOf(Object o);//返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
boolean isEmpty();//如果此列表不包含元素，则返回 true 。
int size();//返回此列表中的元素数。
List<E> subList(int fromIndex, int toIndex)；//返回此列表中指定的 fromIndex （包括）和 toIndex之间的独占视图。
Object[] toArray();//以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
modCount
modCount指的是修改次数，所有使用modCount的容器类都是非线程安全的。该字段表示list结构上被修改的次数。结构上的修改指的是那些改变了list的长度大小或者使得遍历过程中产生不正确的结果的其它方式。该字段被Iterator以及ListIterator的实现类所使用，如果该值被意外更改，Iterator或者ListIterator 将抛出ConcurrentModificationException异常， 这是jdk在面对迭代遍历的时候为了避免不确定性而采取的快速失败原则。 子类对此字段的使用是可选的，如果子类希望支持快速失败，只需要覆盖该字段相关的所有方法即可。单线程调用不能添加删除terator正在遍历的对象， 否则将可能抛出ConcurrentModificationException异常，如果子类不希望支持快速失败，该字段可以直接忽略。
快速失败（fail-fast）想深入了解可以看看：java中的fail-fast(快速失败)机制
还有前面serialVersionUID看这篇文章就够了：对象序列化为何要定义serialVersionUID的来龙去脉
null值在ArrayList中是允许的，传进来的对象一般要先判断是否为null，再进行下一步操作（是否为null会导致操作略有不同）。
总结
学习了以上的内容，可知ArrayList在快速、随机访问上有较高效率，但是增加、删除的效率低下，且非线程安全，那要如何解决这个问题？有三种方法：1、改用Vector；2、使用java.util.Collections工具类，它提供了synchronizedList封装使其安全；3、使用CopyOnWriteArrayList实现写时复制、读写分离。
