本文基于jdk1.8
JavaCollection库中有三类：List，Queue，Set
其中List，有三个子实现类：ArrayList，Vector，LinkedList
http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/tip/src/share/classes/java/util/ArrayList.java
实现原理
transient Object[] elementData; // 存放元素的数组 private int size; // 实际存放元素的数量
ArrayList底层是使用一个Object类型的数组来存放数据的，size变量代表List实际存放元素的数量
add,remove,get,set,contains操作
get和set方法，都是通过数组下标，直接操作数据的，时间复杂度为O(1)
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
public int indexOf(Object o) {
// 遍历所有元素找到相同的元素，返回元素的下标，
// 如果是元素为null，则直接比较地址，否则使用equals的方法比较
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;
}
add
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 扩容检测
elementData[size++] = e; //新增元素添加到末尾
return true;
}
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // 扩容检测
// 使用System.arraycopy的方法，将index后面元素往后移动1位
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element; // 存放元素到index位置
size++;
}
remove
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; // 方便JVM进行GC操作，避免出现泄露
return oldValue;
}
扩容策略
ArrayList底层是使用数组存储的，当数组大小不足存放新增元素的时候，才会发生扩容。
在add操作中，ArrayList首先会调用ensureCapacityInternal方法进行扩容检测的。
如果数组大小不足，则会自动扩容；如果扩容后的大小超出数组最大的大小，则会抛出异常。
ensureCapacityInternal(size + 1);
ArrayList扩容方案，主要有两个步骤：1.大小检测，2.扩容
- 大小检测：
- 检测数组大小是否为0，如果是，则使用默认的扩容大小10
- 检测是否需要扩容，只有当数组最小需要容量大小大于当前数组大小时，才会进行扩容
- 扩容：grow和hugeCapacity
- 进行数组越界判断
- 拷贝原始数据到新的数组中
private void ensureCapacityInternal(int minCapacity) {
// 通过ArrayList<Integer> a = new ArrayList<Integer>()或者通过序列化读取，元素大小为0时，底层数组才会为null数组
// 如果底层数组大小为0，则使用默认的容量大小10
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
// 数据结构发生改变，和fail-fast机制有关，在使用迭代器过程中，只能通过迭代器的方法（比如迭代器中add，remove等），修改List的数据结构，
// 如果使用List的方法（比如List中的add，remove等），修改List的数据结构，会抛出ConcurrentModificationException
modCount++;
// 当前数组容量大小不足时，才会调用grow方法，自动扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
// 新的容量大小 = 原容量大小的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0) //溢出判断，比如minCapacity = Integer.MAX_VALUE / 2, oldCapacity = minCapacity - 1
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);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
fail-fast机制的实现
fail-fast机制也叫作”快速失败”机制，是Java集合中的一种错误检测机制。
在对集合进行迭代过程中，除了迭代器可以对集合进行数据结构上进行修改，其他的对集合的数据结构进行修改，都会抛出ConcurrentModificationException错误。
这里，所谓的进行数据结构上进行修改,是指对存储的对象，进行add,set,remove操作，进而对数据发生改变。
ArrayList中，有个modCount的变量，每次进行add，set，remove等操作，都会执行modCount++。
在获取ArrayList的迭代器时，会将ArrayList中的modCount保存在迭代中，
每次执行add,set,remove等操作，都会执行一次检查，调用checkForComodification方法，对modCount进行比较。
如果迭代器中的modCount和List中的modCount不同，则抛出ConcurrentModificationException
final void checkForComodification() {
if (expectedModCount != ArrayList.this.modCount)
throw new ConcurrentModificationException();
}
使用场景
ArrayList的使用场景主要从其优缺点来考虑的：
优点：
get，set，时间复杂度为O(1)
add（一般都是在末尾插入），时间复杂度为O(1)，最差情况下（往头部插入数据），时间复杂度O(n)
数据存储是顺序的
缺点：
remove，时间复杂度为O(n)，最优情况下（移除末尾元素），时间复杂度为O(1)
ArrayList底层使用数组存储数据，数组是不能自动扩容的，因此在发生扩容的情况下，需要移动大量的元素。
ArrayList大小很大的时候，会存在空间浪费（可以通过trimToSize方法，清除空闲空间）
数组大小是由限制的，受jvm和机器的影响，当扩容超出上限时，ArrayList会抛出异常
插入操作多，数据量不大，顺序存储时，可以考虑使用ArrayList
多线程情况下：
ArrayList所有的操作，都不是同步的，因此ArrayList不是线程安全的。
如果考虑到线程安全的话，可以使用CopyOnWriteArrayList或者外部同步ArrayList（List list = Collections.synchronizedList(new ArrayList(…));）
思考
1.remove方法中，为什么会将数组对应的元素置为null？
ArrayList内部使用数组实现一套管理对象的机制，remove操作中，已经将元素的数量-1了，ArrayList认为该对象已经被移除了，应该被jvm回收。
但是，对于jvm来说，该值仍然保存在数组中，ArrayList持有这个对象的引用，在jvm发生GC时，这个对象是不对被jvm回收，这样就会造成内存泄露了。
2.查找元素的方法中（比如indexOf），为什么需要对元素进行null值判断？
判断对象是否相等，有两个方面，1.对象存储的地址；2.对象的内容。
==，是用来比较两个对象的地址是否相等，一般来说，两个对象的地址相同，那么这两个对象可以认为是相同的对象
equals方法，是用来比较对象内容的，当然，也可以重载该方法，直接比较对象地址；Object对象的equals方法，是比较地址的。
一般来说，重载equals方法的同时，也要重载hashCode方法的，重载hashCode方法，必须得遵守6个原则：
- 自反性：对于任何非null的引用值x，x.equals(x),必须返回true
- 传递性：对于任何非null的引用值x,y,z，如果x.equals(y) 为true，且y.equals(z)为true，那么x.equals(z)必须为true
- 对称性：对于任何非null的引用值x,y，如果x.equals(y)为true，那么y.equals(x)必须为true
- 非空性：对于任何非null的引用值x,x.equals(null)必须为false
- 一致性：对于任何非null的引用值x，y，如果多次调用equals方法，如果x和y比较的值没有改变，那么x.equals(y)就会一致性返回true或者false
为什么重载equals方法，一般要重载hashCode方法？
重载equals方法，可以不重载hashCode方法，但是一般情况，不建议这么做。
hashCode方法，使用来求出对象的Hash值，
重载hashCode方法主要是为了提高一些容器（比如HashMap，Hashtable）进行hash运算的效率，而且也可以避免出现一些错误（比如HashSet容器的操作）
对于元素进行null值判断，我认为主要是为了效率考虑，如果是null值的话，可以直接比较地址，而非空值，则需要通过equals方法来比较，由于ArrayList是泛型的，
所以其添加的元素，可能重载equals方法，自定义了判断的原则。
3.grow方法中，对新容量大小进行判断，为什么会定义MAX_ARRAY_SIZE的？
ArrayList底层存储是使用数组来实现的，所以ArrayList存储文件的大小必定受数组大小的限制，所以在扩容中，可以看到ArrayList对新容量大小进行逻辑判断。
影响数组最大值：
- 理论上最大值为Integer.MAX_VALUE(2^32 - 1)
- 对象头限制，不同类型的元素，可创建数组的最大值是不同的，byte是1字节，int是4字节
比如jvm可用内存为1M，32位机器下，
int[] bytes = new int[1024 * 1024 / 4]; byte[] bytes = new byte[1024 * 1024];
- jvm可用内存大小限制
比如jvm可用内存为1M，32位机器下，
byte[] bytes = byte[1024 * 1024]
至于为什么MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
主要是在64为机器中，对象的