Java基础集合篇-ArrayList
List接口下有三个实现类：ArrayList、LinkedList和Vector
ArrayList
ArrayList简介
ArrayList继承于AbstractList，实现了List，RandomAccess，Cloneable，java.io.Serializable这些接口。
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
}- RandomAccess是一个标志接口，表明实现这个接口的List集合是支持
快速随机访问的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。 - ArrayList实现了
Cloneable接口，即覆盖了函数clone()，能被克隆。 - ArrayList实现了
java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。
ArrayList扩容机制分析
1.ArrayList的构造函数
/**
* 默认初始容量大小
*/
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
*默认构造函数，使用初始容量10构造一个空列表(无参数构造)
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 带初始容量参数的构造函数。（用户自己指定容量）
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {//初始容量大于0
//创建initialCapacity大小的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {//初始容量等于0
//创建空数组
this.elementData = EMPTY_ELEMENTDATA;
} else {//初始容量小于0，抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
*构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
*如果指定的集合为null，throws 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;
}
}以无参数构造方法创建ArrayList时，实际上初始化赋值给elementData的是一个空数组。当其添加第一个元素时，数组容量扩为DEFAULT_CAPACITY=10.
2.add()方法
add方法会首先调用ensureCapacityInternal(int minCapacity)方法。这个方法的作用是判断当前容量是否能容纳下minCapacity，如果不能则扩容。然后再将新元素e添加入elementData数组中。
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}3、ensureCapacityInternal(int minCapacity)的代码
在ensureCapacityInternal()的实现中（下面代码版本是jdk8）。
1、调用calculateCapacity(elementData, minCapacity)。该方法的作用是判断如果elementData==DEFAULTCAPACITY_EMPTY_ELEMENTDATA，那么如果minCapacity<10，那么minCapacity就是10，否则minCapacity不变。得到最终的minCapacity。
2、然后调用ensureExplicitCapacity(int minCapacity)。该方法的作用是判断minCapacity-elementData.length是否大于0，如果大于0，则调用grow()函数扩容。
具体而言，当add第一个元素时，minCapacity-elementData.length=10，因此需要调用grow(10)，将ArrayList扩容至10.当添加2,3…10个元素时，容量足够，无需扩容。而add第11个元素时，容量不足，需要再次调用grow()扩容。
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// minCapacity-最小容量，elementDat==DEFAULTCAPACITY_EMPTY_ELEMENTDATA
// 则minCapacity的最小值为10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
// 如果最小容量大于当前elementData的大小，
if (minCapacity - elementData.length > 0)
// 调用grow方法进行扩容，调用此方法代表已经开始扩容了
grow(minCapacity);
}4、grow()方法
以下代码版本是jdk8。
每次扩容，新容量newCapacity是旧容量的oldCapacity1.5倍。如果新容量还是小于minCapacity，则让newCapacity=minCapacity。
具体而言：
- 当add第1个元素，newCapacity=oldCapacity=0，而minCapacity是10.因此，newCapacity=10.
- 当add第11个元素，newCapacity为15，比minCapacity（为11）大。因此newCapacity就是15.
hugeCapacity()方法：
如果newCapacity大于MAX_ARRAY_SIZE，进入hugeCapacity()方法比较minCapacity和MAX_ARRAY_SIZE，如果minCapacity大于最大容量，则新容量为Integer.MAX_VALUE,否则，新容量为MAX_ARRAY_SIZE。
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
/**
* ArrayList扩容的核心方法
* @param minCapacity
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 检查新容量是否大于最小需要容量，若还是小于最小需要容量
// 那么就把最小容量当作数组的新容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 再检查新容量是否超出了ArrayList定义的最大容量
// 若超出了，则调用hugeCapacity()来比较minCapacity和MAX_ARRAY_SIZE
// 如果minCapicity大于MAX_ARRAY_SIZE，则新容量为Integer.MAX_VALUE,否则，新容量大小为MAX_ARRAY_SIZE
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);
}
// 比较minCapacity 和 MAX_ARRAY_SIZE
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}ensureCapacity方法
ArrayList源码（下面提供的是jdk8版本）中提供了一个ensureCapacity(minCapacity)方法。由于在扩容时，使用Arrays.copyOf()函数，该函数将原有的元素复制到新数组，这个操作是很浪费时间的。因此添加大量元素时，应该减少扩容次数。这时，就可以先调用ensureCapacity(minCapacity)方法，将List一次扩充至需要的大小。
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}ArrayList和Vector的区别？
- ArrayList是List的主要实现类，底层使用
Object[]存储，适用于频繁的查找工作，线程不安全 - Vector是List的古老实现类，底层使用
Object[]存储，线程安全的。
Arraylist 与 LinkedList 区别?
1、是否保证线程安全：ArrayList和LinkedList都是不同步的，也就是不保证线程安全。
2、底层数据结构：ArrayList底层使用的是Object数组；LinkedList底层使用的是双向链表数据结构
3、插入和删除是否收元素位置的影响：
ArrayList采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。在尾部添加时间复杂度是O(1)。如果在指定位置i插入或者删除元素（add(int index,E element)）时间复杂度就是O(n-i)。因为在进行上述操作时，需要将第i个之后的(n-i)个元素（包括第i个）向后/向前移动1位（源码中使用System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)）方法。
LinkedList采用链表存储，虽然增加或者删除操作是O(1)，但是如果需要在指定位置增加或者删除首先要遍历到这个位置，因此总的时间复杂度近似O(n)。
4、是否支持快速随机访问：LinkedList不支持高效的随机访问，而ArrayList支持。快速随机访问就是通过元素的序号快速获取元素对象
5、内存空间占用：ArrayList的空间浪费主要体现在在列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（存放前驱节点和后驱节点）。
