一、介绍
对于ArrayList，可以说诸位绝不陌生，可以说是在诸多集合中运用的最多一个类之一，那么它是怎样构成，怎样实现的呢，相信很多人都知道数组构成的，没毛病，如果遇到面试的时候，估计还会问，它的默认大小是多少？它是怎样扩容的？它的一个属性modCount有啥作用？线程安全性怎么样？。。。。等待一系列问题。下面就围绕着对该集合的运用来展开，如增删改查，这四个方面。在介绍之前，先来看看该集合的性质
- 里面的元素是有序的（指的是添加的顺序和排列的顺序是一致的）
- 可以添加重复元素
- 增删慢，查询快
- 内部采用了Object数组来存储元素，size为元素个数
- 有线程安全问题
我准备了一套Java编程学习资料，加群：985331340免费领取，你敢来我就敢送。
二、增加
先来贴下增加元素的源码
public Boolean add(E e) {
ensureCapacityInternal(size + 1);
// Increments modCount!!
elementData[size++] = e;
return true;
}添加某个元素，在使用默认构造函数的时候，且是第一次添加元素，第三行代码会触发初始化操作，即对数组扩容到默认大小10，点进去看，如下
private void ensureCapacityInternal(int minCapacity) {
//若使用的默认构造函数，且是第一次添加，则返回true，此时开始初始化话
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
//10
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
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);
}如上可以看出扩容步骤：
- 先判断有没有初始化，没有则初始化，有则跳过这步骤
- 检查要扩容的大小和数组的长度哪个大，如果数组长度大，则还没到需要扩容的时候即跳过，进行添加元素同时size+1，反之，则进行下一步grow方法(这里说明下关于size和数组的大小，这两个是不同的概念，这两者关系必满足size<=length，size指的是数组里的元素个数，length指的是数组长度）
- grow()，该方法是ArrayList扩容的关键方法，在它里面有这几个逻辑判断(注意此时意味着minCapacity超过了数组的长度length)
- 获取数组长度，为扩容大小提供值
- 默认扩大为原数组长度的1.5倍(这里面有精度运算，不一定真的恰好是1.5倍)，你扩容后的长度newCapacity它的值为原数组长度+该长度向左移1个长度(即除以2)，如，原来是10，则扩容后为10+10>>1=15。
- 扩容后长度再去和传进来的参数minCapacity去比较大小，取最大值，将最大值赋值为扩容后的长度。
- 扩容后的长度再去和MAX_ARRAY_SIZE做上一步操作，该值为Integer.MAX_VALUE - 8，可以知道ArrayList里数组最大的长度就是Integer.MAX_VALUE，这步在hugeCapacity里
- 利用工具类Arrays去扩容(实际是先new了一个数组，再利用System类的元素复制将元素移动到新数组里，再返回，至于为啥不用for循环，因为这个类的效率比for循环高，是一个本地方法)
以上就是扩容步骤，
扩容完之后，就开始添加元素了elementData[size++] = e;同时size增一。
对于ArrayList方法其它add重载方法，就不一一介绍了，扩容步骤都是一样的，
三、移除
同样，先贴下代码
public E remove(int index) {
rangeCheck(index);
//当index>=size会抛异常
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;
}先去检查移除的位置的正确性，或许会有人问，怎么不去检查index是否大于0？其实继续往下看就知道了，在第五行代码，若为负数的话，则会直接抛异常ArrayIndexOutOfBoundsException。
若index在正常范围内，则去判断要不要移动元素，即index后面的所有元素都往前移动一步，最后将size-1这个位置的元素设为null，来帮助垃圾回收，返回旧值。。
对于它的重载函数，remove(Object o),代码如下，要注意的是，它移除的是从数组下标为0开始往后找的第一个元素，再利用fastRemove来进行移除(和上一个remove(int)比较就是少了index判断)，最后返回true，移除成功，fasle移除失败
public Boolean remove(Object o) {
if (o == 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])) {
fastRemove(index);
return true;
}
}
return false;
}该集合还提供大规模的移除，不过用的不多(提供给子类和同包类用的)。贴下代码
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// clear to let GC do its work
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}具体原理和之前移除一个元素一样，不过多叙述
四、查找
前面的介绍说该集合查找快，让我们，它比增删快在哪？
public E get(int index) {
rangeCheck(index);
return elementData(index);
}代码非常精简，检查了下index的正确性，然后直接返回，因为它是一个数组，可以直接定位下标。相比增删，少了移动元素，少了新创建数组。必然快，而对于LinkedList这个集合，却和ArrayList相反，关于LinkedList这个集合，在后面的博文中会出现，到时候会做一个比较。
五、修改
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}同样先检查index的正确性，然后直接改变原index位置的值，返回旧值。
六、modCount的作用
细心的人会发现，每一次的增删都有modCount这个变量的出现，并且每次都是+1，至于为什么进行“改查”modCount却不改变，这是因为，该集合是一个数组，如果进行增加或删除，则size必然改变，那么在遍历过程中，肯定找不到正确的结果或者直接数组越界异常，这都是我们不想要的，改查，只是改变元素值，而不是元素个数。在了解这个变量之前，先来了解下，快速失败(fail-fast)和安全失败(fail-safe)的两个概念.
- fail-fast 快速失败，产生于遍历集合过程中，如某个线程对集合集合遍历时，有另外线程对该集合做修改操作，则会抛出ConcurrentModificationException异常，其作用是用来检测错误，并不一定发生。
- fail-safe 安全失败，在遍历集合，并不是直接在原集合中操作，而是先复制一个集合，在复制的集合中操作，这样就不会产生ConcurrentModificationException异常。缺点是改变后不能看到改变后的结果。
其中安全失败里提到的复制集合，并不是直接将原来的集合赋给新集合，如list_1=list_2，这样只是把内存中的引用地址给了list_1，如果list_1也进行增删操作，那么list_2也能得到相应的结果，即两个集合操作都是对同一个堆内存的地址里的数据进行操作，前面说的复制是另开辟一个堆内存。(切记)。
在了解这两个概念后，应该可以猜的出来，modCount的作用就是用来fail-fast的，具体体现在如下
查看ArrayList源码可知，它有一个内部类Itr(实现了Iterator)，这个类的作用就是使ArrayList集合可以迭代操作，该类有这几个方法，如下图
private class Itr implements Iterator<E> {
int cursor;
// index of next element to return
int lastRet = -1;
// index of last element returned; -1 if no such
int expectedModCount = modCount;
public Boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
3 int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
}
catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}在建立该类的实例，首先会初始化几个成员变量，cursor和、astRet、expectedModCount，值依次为0，-1，modCount。
hasNext()，是用来判断集合有没有下一个元素，该代码是直接判断当前指针cursor和元素个数size是否相等。
next()，先会去检查modCount的值和expectedModCount值是否相等，如果不等，则直接抛出异常，看到这，或许大家就明白了modCount的作用了吧，modCount值要改变必然要对集合进行增或删操作。之后就取当前指针cursor位置的值。
remove()，该方法也是首先会去判断集合有没有被改变，之后进行相应操作。
七、最后
对于ArrayList的线程安全问题，可以采用工具类Collections，该类有一个方法synchronizedList(List)，可保证线程安全，但效率可能有点低，
还有一个方法就是采用CopyOnWriteArrayList类来操作数据。