一.ArrayList
1. 重点概念归纳
- List接口的可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。
- 非线程安全。在多线程情况下操作时，一定要加上synchronized，才能保证多个线程同时对ArrayList进行访问时数据的安全性。
- 底层使用的数据结构是数组。
- 适合查改，弱于增删。
- 实现了Serializable接口，因此它支持序列化，能够通过序列化传输。
- 实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问。
- 实现了Cloneable接口，能被克隆。
2. ArrayList源码详细注释解读
代码自己逐个方法、重要的地方都标明了中文注释，可以直接阅读代码，后面会详细分析。（注意：关于ArrayList类相比较旧版本是有改动的，此文研究的是1.7版本的源码！后面也会大致分析新旧版本的区别，自己是对照了新旧版本一点点改的）
package java.util;
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
// 序列版本号
private static final long serialVersionUID = 8683452581122892189L;
//默认列表容量
private static final int DEFAULT_CAPACITY = 10;
//用于空实例的共享空数组实例
private static final Object[] EMPTY_ELEMENTDATA = {};
//用于默认大小的空实例的共享空数组实例，与EMPTY_ELEMENTDATA不同，当添加第一个元素时知道扩容多少
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* ArrayList基于该数组实现，用该数组保存数据
* 不置为私有域是为了方便嵌套类访问
*/
transient Object[] elementData;
// ArrayList中实际数据的数量
private int size;
// ArrayList的构造函数，有明确的容量要求
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);
}
}
// ArrayList无参构造函数
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 创建一个包含collection的ArrayList，为了返回 collection的迭代器
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实例的容量，将当前容量值设为实际元素个数
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
//------------------------------------ start ---------------
/**
* 增加ArrayList实例的容量，确保它至少可以容纳元素的数量，数量由最小容量参数指定
*
* @param minCapacity 最小容量
*/
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)
ensureCapacityInternal(minCapacity);
}
private void ensureCapacityInternal(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
//若传入的要求容量大小大于列表目前大小，则调用grow方法增容
grow(minCapacity);
}
/**
* 可分配给数组的最大容量
*
* 尝试分配较大的数组可能会导致OutOfMemoryError：请求的数组大小超过VM限制
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 增加容量，以确保它至少能够容纳最小容量参数指定的元素数
*
* @param 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)
//若计算的新容量大于规定列表最大值，则调用hugeCapacity方法
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
//当grow中算法计算的新容器值大于规定最大值，则比较参数值和规定最大值，返回两者最小值
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
//------------------------------------ end ---------------
// 返回ArrayList的实际大小
public int size() {
return size;
}
//返回ArrayList是否为空
public boolean isEmpty() {
return size == 0;
}
// ArrayList是否包含Object(o)
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
// 正向查找，返回指定元素的第一次出现的索引，如果此列表不包含元素，则为-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;
}
// 反向查找，返回元素的索引值
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;
}
// 反向查找(从数组末尾向开始查找)，返回元素(o)的索引值
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 Object clone() {
try {
ArrayList<E> v = (ArrayList<E>) super.clone();
// 将当前ArrayList的全部元素拷贝到v中
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
// 返回ArrayList的Object数组
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
// 返回ArrayList元素组成的数组
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
// 若数组a的大小 < ArrayList的元素个数；
// 则新建一个T[]数组，数组大小是“ArrayList的元素个数”，并将“ArrayList”全部拷贝到新数组中
if (a.length < size)
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
// 若数组a的大小 >= ArrayList的元素个数；
// 则将ArrayList的全部元素都拷贝到数组a中。
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
// 位置访问操作
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
// 获取index位置的元素值
public E get(int index) {
rangeCheck(index);
return (E) elementData[index];
}
// 设置index位置的值为element
public E set(int index, E element) {
rangeCheck(index);
E oldValue = (E) elementData[index];
elementData[index] = element;
return oldValue;
}
// 将e添加到ArrayList中
public boolean add(E e) {
ensureCapacity(size + 1); //如果列表长度不足，进行扩容。
elementData[size++] = e;
return true;
}
// 将e添加到ArrayList的指定位置
public void add(int index, E element) {
rangeCheckForAdd(index); //新版本增加的
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
// 删除ArrayList指定位置的元素
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = (E) elementData[index];
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // GC垃圾回收期会回收无引用对象
return oldValue;
}
// 删除ArrayList的指定元素
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
// 遍历ArrayList，找到“元素o”，则删除，并返回true。
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
// 快速删除第index个元素
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
// 从"index+1"开始，用后面的元素替换前面的元素。
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 将最后一个元素设为null
elementData[--size] = null; // Let gc do its work
}
// 清空ArrayList，将全部的元素设为null
public void clear() {
modCount++;
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
// 将集合c追加到ArrayList中
public boolean addAll(Collection<? extends E> c) {
rangeCheckForAdd(index); //新版本增加的
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); //如果列表长度不足，进行扩容。
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
// 从index位置开始，将集合c添加到ArrayList
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: " + index + ", Size: " + size);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); //如果列表长度不足，进行扩容。
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;
}
// 删除fromIndex到toIndex之间的全部元素。
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// Let gc do its work
int newSize = size - (toIndex-fromIndex);
while (size != newSize)
elementData[--size] = null;
}
//检查下标是否超出范围
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/** 新版本增加的
* 此版本被用于 add 和 addAll.
*/
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
//从此列表中删除其中包含的所有元素
public boolean removeAll(Collection<?> c) {
return batchRemove(c, false);
}
//仅保留此列表中指定集合包含的元素，换句话说，从这个列表中删除所有不包含在指定的集合中的元素。
public boolean retainAll(Collection<?> c) {
return batchRemove(c, true);
}
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
/*
* java.io.Serializable的写入函数
* 将ArrayList的“容量，所有的元素值”都写入到输出流中
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// 写入“数组的容量”
s.writeInt(elementData.length);
// 写入“数组的每一个元素”
for (int i=0; i<size; i++)
s.writeObject(elementData[i]);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
// java.io.Serializable的读取函数：根据写入方式读出
// 先将ArrayList的“容量”读出，然后将“所有的元素值”读出
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// 从输入流中读取ArrayList的“容量”
int arrayLength = s.readInt();
Object[] a = elementData = new Object[arrayLength];
// 从输入流中将“所有的元素值”读出
for (int i=0; i<size; i++)
a[i] = s.readObject();
}
//返回列表中的列表迭代器
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
......
//有关获取迭代器的代码就不贴了
}
3. 源码重点解析
以下介绍ArrayList源码中常见且重点的8个方法，了解后基本已经可以掌握ArrayList源码精髓了，来一探究竟：
（1）构造函数
ArrayList类有三个重载的构造方法：
ArrayList()
无参数默认构造方法，创建列表（即数组)的容量大小默认为10。ArrayList(int initialCapacity)
带有int参数的构造方法，参数为创建列表时要求容量，创建一个大小为initialCapacity的列表。ArrayList( Collection< ? extends E > c)
带有Collection参数的构造方法，将Collection转化为数组赋给ArrayList的实现数组elementData。
（2）ensureCapacity 方法
此方法比较重要，需重视。功能为扩充容量，在每次对列表进行有关添加的操作都会调用此方法为数组扩容。ArrayList在每次增加元素时（调用add方法时是增加1个元素，即传入的参数是当前总数+1，调用addAll方法时增加一组元素，传入方法参数是当前总数+一组总数），都要调用该方法来确保足够的容量。
决定扩容后最新容量值的逻辑
参考代码具体实现，首先类中有个常量MAX_ARRAY_SIZE，它是可分配给数组的最大容量，为Integer.MAX_VALUE - 8，是一个很大的数值了。在继续之前ensureCapacity方法有个算法：根据列表当前容量大小，采用右位移运算符将数值二进制移动一位，得到一位新值（肯定会比列表当前容量大）。注意：旧版本中计算此数值的算法是：新的容量为列表当前容量的1.5倍加1。将计算的新容量值和参数容量值进行比较，如果小于参数容量值，则以参数容量值为准进行扩容；反之当计算的新容量值大于规定值时，不能这么轻易的将它决定为最终结果，会继续判断参数规定值是否小于0（如果是的情况下计算值总会大于规定值，则抛出异常），然后继续判断计算值是否大于最大限制值（不可超出最大限制值）
性能
以上过程就是决定扩容后的最新容量值的逻辑，决定好后用Arrays.copyof()方法将元素拷贝到新的数组（详见下面的第3点）。可以看出，因为ArrayList底层是动态数组，创建时确定好容量数值后，每次不够需要扩容时，都需要将原来的元素拷贝到一个新的数组中，这是一个非常耗时的过程。因此从性能方面考虑，建议在能够确定容量大小的情况下采用ArrayList，不确定的情况下采用LinkedList。
（3）Arrays.copyof() 方法和 System.arraycopy() 方法
在上一点已经提到过此方法，ArrayList的实现中大量地调用了，功能即将元素拷贝到新的数组。来查看其代码实现，这里有多个重载方法，实现思路相同，来看其中一个即可：
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
} 所以其实真正调用的是copyOf()方法，可以看出该方法实际上是在其内部又创建了一个长度为newlength的数组，调用System.arraycopy()方法，将原来数组中的元素复制到了新的数组中。
而System.arraycopy()方法被标记为native，调用了系统的C/C++代码，只能在openJDK中查看源码。这里简单说明一下，此方法实际上调用了C语言的memmove()函数，所以它可以保证同一个数组内元素的正确复制和移动，效率比一般的复制方法高，适合用于批量处理数组。在Java中也比较推荐使用此方法达到更好的效率。
（4）toArray 方法
ArrayList中有两个实现toArray 转化为静态数组的方法：
public Object[] toArray()
此方法直接调用Arrays.copyof()并将结果返回，这样做有潜在危机，有可能会抛出ClassCastException异常。例如：直接用向下转型的方法，将整个ArrayList集合转变为指定类型的Array数组，便会抛出该异常。但是，如果转化为Array数组时不向下转型，而是将每个元素向下转型，则不会抛出该异常。这样的做法明显效率低下，且不太方便。public T[] toArray(T[] a)
方法一开始会进行判断，若数组a的容量个数小于ArrayList的元素个数，则新建一个T[]数组，数组大小是“ArrayList的元素个数”，并将“ArrayList”全部拷贝到新数组中 。反之则将ArrayList的全部元素都拷贝到数组a中。该方法可以直接将ArrayList转换得到的Array进行整体向下转型，效率较高。
（5）add 增加方法
add(E e)
功能就是将新元素增加到列表尾部。照例，首先调用ensureCapacity方法来确保容量是否满足，即确保列表中还有额外的一个容量，然后将列表的末尾值设置为新值，返回True代表成功。add(int index, E element)
不同于上一个函数将新元素直接增加到列表尾部，此功能是将新元素增加到指定位置index。来查看方法实现，由于都是增加元素必然会调用到ensureCapacity方法来确保容量是否满足，可是在此操作之前还需判断index是否合法（指定下标小于0或大于列表总长度）。一切准备就绪开始插入元素，注意ArrayList底层原理是数组，所以需要将列表中index后的元素全部往后移动一位，空出一个位置留给新元素，这里就用到上面介绍到的System.arraycopy()方法进行元素拷贝。最后赋值、总长度加1即完成操作。
（6）remove 删除方法
remove(int index)
功能即移除此列表中指定位置上的元素。来查看方法实现，照例，首先判断下标是否合法，然后同增加方法一样，需要将列表中index后的值全部向前移动一位，调用System.arraycopy()方法进行元素拷贝，最后将列表中最后一个元素赋值null，这里不需要担心此对象占用空间，因为GC会处理无引用对象。remove(Object o)
功能为删除ArrayList的指定元素，注意这里是以指定元素去删除列表中元素。实现方法稍有不同，首先会判断参数是否为null，如为null它并不会报错，因为存在列表中有元素为null的情况，这时开始遍历列表，移除找到的第一个值为null的元素；为不为null则遍历比较是否有相同元素，没有返回False，反之则移除，返回TRue，移除方法与上述remove(int index)相同，在此不赘述。
（7）set 修改方法
- set(int index, E element)
功能就是把这个列表上某一个元素的值进行变更修改。首先检查修改的index下标是否合法，即检查下标是否越界，然后将列表中原index的值取出保存到oldValue中返回，将值设置为更新的新值。很普通的数组修改值实现，并无太大难度。
（8）get 查找方法
- get(int index)
功能为根据下标返回列表中对应元素。首先会检查下表是否合法，然后由于列表底层由数组实现，所以直接将下标对应值返回即可。
4. 新旧版本比较
（1）ensureCapacity 扩容方法的算法
相信了解了以上只是点后，读者认识到了扩容方法ensureCapacity的重要性，然后，在旧版本中该方法的主要逻辑却有些不同，来看该方法的旧版本实现：
【旧版本】
// 若ArrayList的容量不足以容纳当前的全部元素，设置 新的容量=“(原始容量x3)/2 + 1”
public void ensureCapacity(int minCapacity) {
// 将“修改统计数”+1，该变量主要是用来实现fail-fast机制的
modCount++;
int oldCapacity = elementData.length;
// 若当前容量不足以容纳当前的元素个数，设置 新的容量=“(原始容量x3)/2 + 1”
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1;
//如果还不够，则直接将minCapacity设置为当前容量
if (newCapacity < minCapacity)
newCapacity = minCapacity;
elementData = Arrays.copyOf(elementData, newCapacity);
}
}核心算法
首先我们直接看newCapacity 这个变量，它是根据列表当前容量经过算法计算后得到的新值，旧版本中的算法是：新的容量值为列表当前容量的1.5倍加1。而新版本中的算法：根据列表当前容量大小，采用右位移运算符将数值二进制移动一位，得到一位新值。
这样的做法明显是优化了该方法，采取更适合的方法去计算这个新容量值。
核心逻辑
可已看出，旧版本中的逻辑比较简单，当前容量不满足规定容量时，根据算法去计算新值，以新值和规定值中的最大值为准。而新版本中引入了一个列表容量的最大限制常量值MAX_ARRAY_SIZE，在旧版本的逻辑基础上多加了一步，即当计算的值大于规定值时，不能这么轻易的将它设置成新容量值，会继续判断参数规定值是否小于0（如果是的情况下计算值总会大于规定值，则抛出异常），然后继续判断计算值是否大于最大限制值（不可超出最大限制值）。
相较于旧版本，新版本中的逻辑判断更加严密，对数值的边界值、不规范等情况更方面都做了考虑。
（2）方法单独封装
这一点就是有关于Java编程规范相关的内容了，我在对照新旧版本时发现明显不同的一点，比如ensureCapacity方法，旧版本直接一个方法将所有逻辑写完，而在新版本中分解成了3个方法去实现，每个方法分工明确、职责单一，提供了更清晰的单独方法封装；还有个例子，判断参数是否符合规范，在旧版本中的if判断直接在逻辑方法中，在新版本却把它独立出作为一个方法判断，代码如下：
/** 新版本增加的
* 此版本被用于 add 和 addAll.
*/
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}即使只是一个简单的if判断，你可能觉得加到方法中也无可厚非，但是大量重复代码积累会显得程序冗长，所以需要时应该讲单独职责的方法封装出来，这样各方法之间分工明确，也更符合设计原则中的单一职责概念。
（3）命名规范
这是一个很基本的概念，涉及到变量、方法的命名规范，在旧版本中却有这样的方法定义：
private void RangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
} 没错，该方法名开头字母是大写，对此我也有些不解，在新版本中已经改为小写。关于命名规范，阿里已经发布过相关规则，大家遵从这些基本规则会养成良好的代码习惯，对以后编程有很大帮助。
（4）新增内部类
在ArrayList中获取迭代器iterator的方法中，方法体统一返回的都是匿名内部类，而类实现是ArrayList中的内部类，代码如下：
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
......
}（关于迭代器这一块我没有贴代码，感兴趣的可以直接去看源码）
如有错误，望指教~
希望对你们有帮助：）