ArrayList源码解读
ArrayList简介
下文简介翻译自ArrayList源码注释。
List接口的可调整大小的数组实现。 实现所有可选的列表操作，并允许所有元素，包括null 。 除了实现List接口之外，该类还提供了操作内部用于存储列表的数组大小的方法。 （这个类大致相当于Vector ，只是它是不同步的。）
size 、 isEmpty 、 get 、 set 、 iterator和listIterator操作在恒定时间内运行。 add操作在分摊常数 time 内运行，即添加 n 个元素需要 O(n) 时间。 所有其他操作都在线性时间内运行（粗略地说）。 与LinkedList实现相比，常量因子较低。
每个ArrayList实例都有一个容量。 容量是用于存储列表中元素的数组的大小。 它始终至少与列表大小一样大。 随着元素被添加到 ArrayList，它的容量会自动增长。 除了添加元素具有恒定的摊销时间成本之外，没有指定增长政策的细节。
应用程序可以在使用ensureCapacity操作添加大量元素之前增加ArrayList实例的容量。 这可以减少增量重新分配的量。
请注意，此实现不是同步的。 如果多个线程同时访问一个ArrayList实例，并且至少有一个线程在结构上修改了列表，则必须在外部进行同步。 （结构修改是添加或删除一个或多个元素，或显式调整后备数组大小的任何操作；仅设置元素的值不是结构修改。）这通常是通过同步一些自然封装的对象来实现的。列表。 如果不存在此类对象，则应使用Collections.synchronizedList方法“包装”该列表。 这最好在创建时完成，以防止对列表的意外不同步访问：
List list = Collections.synchronizedList(new ArrayList(…));
此类的iterator和listIterator方法返回的iterator是快速失败的：如果在创建迭代器后的任何时间以任何方式修改了列表的结构，除了通过迭代器自己的remove或add方法，迭代器将抛出ConcurrentModificationException 。 因此，面对并发修改，迭代器快速而干净地失败，而不是在未来不确定的时间冒着任意、非确定性行为的风险。
请注意，无法保证迭代器的快速失败行为，因为一般而言，在存在非同步并发修改的情况下不可能做出任何硬保证。 快速失败的迭代器会尽最大努力抛出ConcurrentModificationException 。 因此，编写一个依赖此异常来确保其正确性的程序是错误的：迭代器的快速失败行为应该仅用于检测错误。
此类是Java Collections Framework的成员。
ArrayList结构图解
ArrayList底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。
其内部容量capacity和实际大小size的关系是： 容量 >= 实际大小
ArrayList源码分析
我们从ArrayList的继承结构，以及部分重要参数，构造方法和一些重要方法着手。
1、继承结构
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
结构图如下：
2、重要参数
//序列化id
private static final long serialVersionUID = 8683452581122892189L;
/**
* Default initial capacity.
* 默认的初始化容量为10
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* Shared empty array instance used for empty instances.
* 指定该ArrayList容量为0时，返回该空数组。
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
* 当调用无参构造方法，返回的是该数组。刚创建一个ArrayList 时，其内数据量为0。
* 它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，而EMPTY_ELEMENTDATA是在用户指定容量为0时返回。
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.
* 该数组保存添加到ArrayList中的元素。
* ArrayList的容量就是该数组的长度。
* 该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入ArrayList中时，数组将扩容值DEFAULT_CAPACITY(也就是10)。
* 被标记为transient，在对象被序列化的时候不会被序列化。
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* The size of the ArrayList (the number of elements it contains).
*ArrayList的实际大小（数组包含的元素个数/实际数据的数量）默认为0
*/
private int size;
3、构造方法
ArrayList有三种构造方法：
- public ArrayList(int initialCapacity)
- 构造一个指定容量为capacity的空ArrayList。这是一个带初始容量大小的有参构造函数。
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
//如果大于0，就构造该大小的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//如果等于0，就构造一个空列表
this.elementData = EMPTY_ELEMENTDATA;
} else {
//如果小于0，就抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
- public ArrayList()
- 构造一个容量为10的空列表。(其在第一次添加元素(add)时，容量扩充为10)
public ArrayList() {
//前面属性讲解中提及到该属性
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
- public ArrayList(Collection<? extends E> c)
- 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
public ArrayList(Collection<? extends E> c) {
Object[] a = c.toArray();
if ((size = a.length) != 0) {
if (c.getClass() == ArrayList.class) {
//如果所传参数是ArrayList，直接让数组等于所传参数转换后的数组
elementData = a;
} else {
//如果不是Object[].class类型，那么就需要使用Arrays.copyOf将a转换为Object后拷贝一遍
//参数解释：copyOf(要复制的数组,要返回的副本的长度,要返回的副本的类)
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
//如果所传参数长度等于0，直接将空数组EMPTY_ELEMENTDATA赋值给elementData
elementData = EMPTY_ELEMENTDATA;
}
}
4、重要方法
add方法
add的方法是给list的末尾添加元素， 有两个重载方法，一个是带一个参数的，一个是带两个参数的。
先介绍一个参数的：
public boolean add(E e) {
//确认list容量是否足够，如果不够，扩容。
ensureCapacityInternal(size + 1);
//将e值赋值到size位置上，并让size自增
elementData[size++] = e;
return true;
}
//数组容量检查，不够时则进行扩容，只供类内部使用
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//若elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则取minCapacity为DEFAULT_CAPACITY,DEFAULT_CAPACITY在此之前已经定义为默认的初始化容量是10。
//否则，直接返回所传入的size + 1
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//数组容量检查，不够时则进行扩容，只供类内部使用
// minCapacity为所需的最小容量
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//记录
//当前所需容量>数组原有容量
if (minCapacity - elementData.length > 0)
grow(minCapacity);//扩容
}
//扩容，保证ArrayList内部数组长度足够
private void grow(int minCapacity) {
//获取现在ArrayList的容量
int oldCapacity = elementData.length;
//扩容操作，新的容量=当前容量+当前容量/2.即将当前容量增加一半（当前容量增加1.5倍）。
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果扩容1.5倍后还是不够，直接让现有容量 = 所需容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//如果扩容后的容量大于临界值，则进行大容量分配
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//上述代码将新的容量已经确定，就copy数组，改变数组大小。
//参数解释：copyof(原数组，新的数组长度)
elementData = Arrays.copyOf(elementData, newCapacity);
}
//进行大容量分配
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) //如果minCapacity<0，抛出异常
throw new OutOfMemoryError();
//如果想要的容量大于MAX_ARRAY_SIZE，则分配Integer.MAX_VALUE，否则分配MAX_ARRAY_SIZE
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
看完代码，我们在梳理一下逻辑：
size是数组中数据的个数，因为要添加一个元素，所以先判断size+1和数组长度的大小，calculateCapacity方法用来计算容量，其判断初始化的elementData是不是空的数组。
- 如果elementData元素是空的，就是第一次添加元素，minCapacity=size+1，其实就是等于1，空的数组没有长度就存放不了，所以就将minCapacity变成10，也就是默认容量的大小。
- 如果elementData数组中的元素不是空的，那么它此时需要的最小容量就是原先的数组长度加1，minCapacity代表着elementData中元素增加之后的实际数据个数。
此后我们就带着所需容量进入ensureExplicitCapacity()方法，进入后我们用所需容量与当前数组容量作比较，如果当前数组容量不够就扩容。
加入需要扩容，我们就进入grow函数，我们先会将容量扩大至原先的1.5倍
- 扩容1.5倍后还是不够，直接让现有容量 = 所需容量，谈后将数组扩大
- 扩容1.5倍后的容量大于临界值，则进行大容量分配，然后将数组扩大
- 不满足上述两条件，扩容1.5倍后够用，就将数组扩大至1.5倍
扩容举例：
原容量为10，扩容后：1010 + 1010 >> 1 = 1010 + 0101 = 10 + 5 = 15
原容量为7，扩容后：0111 + 0111 >> 1 = 0111 + 0011 = 7 + 3 = 10
讲完一个参数，我们看两个参数就是易如反掌了
public void add(int index, E element) {
//越界检查
rangeCheckForAdd(index);
//确认list容量是否足够，如果不够，扩容。
ensureCapacityInternal(size + 1);
//将原数组中所有位于index后的元素向后移一位
//参数解释：arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制的数组元素的数量)
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//将添加元素置于index处
elementData[index] = element;
//实际长度+1
size++;
}
//越界检查（index是和实际大小size作比较，而不是和容量作比较）
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
//插入的位置不能大于size和小于0，如果是就报越界异常
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
get方法
public E get(int index) {
//越界检查
rangeCheck(index);
//返回索引为index的元素
return elementData(index);
}
//越界检查
private void rangeCheck(int index) {
if (index >= size)
//如果给出的索引index>=size，抛出一个越界异常
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//报错信息
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
//返回数组中位于index的值
E elementData(int index) {
return (E) elementData[index];
}
因为ArrayList底层是数组，所以它的get方法非常简单，先是判断一下有没有越界
- 没有越界，直接通过数组下标来获取元素。
- 越界，抛出异常
set方法
public E set(int index, E element) {
//越界检查
rangeCheck(index);
//获取原先处于index的元素
E oldValue = elementData(index);
//将新元素置于index处
elementData[index] = element;
//将旧元素返回
return oldValue;
}
set方法的作用：将需要设置的元素放到指定的位置（index）上，然后将原来位置上的元素oldValue返回。
remove方法
- 根据索引remove,通过删除指定位置上的元素
public E remove(int index) {
//越界检查
rangeCheck(index);
modCount++;//结构性修改次数+1
//获取处于index处的元素
E oldValue = elementData(index);
//计算出需要移动的元素个数
int numMoved = size - index - 1;
if (numMoved > 0)
//所需移动元素的个数>0，就开始移动
//参数解释：arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制的数组元素的数量)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//将数组最后一位置为null，以便GC回收
elementData[--size] = null;
return oldValue;
}
//越界检查
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)//插入的位置不能大于size 和小于0，如果是就报越界异常
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
remove删除元素步骤：
- 进行越界检查
- 记录修改次数（modCount 可以用来检测快速失败的一种标志。）
- 通过索引找到要删除的元素
- 计算要移动的位数
- 移动元素（其实是覆盖掉要删除的元素）
- 将size上的位置赋值为null，让gc(垃圾回收机制)更快的回收它。
- 返回被删除的元素
- 根据对象remove
//从列表中删除指定元素的第一个出现项，
//如果它存在的话。如果列表不包含该元素，它将保持不变。更正式地说，删除索引最低的元素...
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;
}
private void fastRemove(int index) {
modCount++;
//计算所需移动元素个数
int numMoved = size - index - 1;
if (numMoved > 0)
//如果所需移动个数 > 0, 开始移动
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//将最后一位置为null,并将size自减
elementData[--size] = null;
}
- removeRange(int fromIndex, int toIndex)：根据范围，remove范围内元素
//从该列表中删除索引位于两者之间的所有元素，包含fromIndex，但是不包含toIndex，将任何后续元素向左移动(减少它们的索引)
protected void removeRange(int fromIndex, int toIndex) {
modCount++;//结构修改次数+1
int numMoved = size - toIndex;//计算所需移动元素个数
//开始移动
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
//计算移除后的实际大小
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
//将数组最后移动个数个元素置空
elementData[i] = null;
}
//替换size值为newSize
size = newSize;
}
- removeAll(Collection<?> c) 和retainAll(Collection<?> c)
public boolean removeAll(Collection<?> c) {
//判空
Objects.requireNonNull(c);
//删除指定集合中的所有元素
return batchRemove(c, false);
}
public boolean retainAll(Collection<?> c) {
//判空
Objects.requireNonNull(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)
//complement为false时，就将c不包含的元素保存
//complement为true时，就将c包含的元素保存
elementData[w++] = elementData[r];
} finally {
//保持与 AbstractCollection 的行为兼容性，即使 c.contains() 抛出。
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
//将w指针及以后的所有数组值设为null
for (int i = w; i < size; i++)
elementData[i] = null;
//结构修改次数增加
modCount += size - w;
//将size更新
size = w;
//更改完返回modified
modified = true;
}
}
return modified;
}
indexOf()和lastIndexOf()方法
//返回此列表中指定元素的第一个出现项的索引，如果该列表不包含该元素，则返回-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;
}
//返回此列表中指定元素的最后一次出现的索引，如果该列表不包含该元素，则返回-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;
}
clear()方法
//从列表中删除所有元素。该调用返回后，列表将为空。
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
总结
- arrayList可以存放null。
- arrayList本质上就是一个elementData数组。
- arrayList区别于数组的地方在于能够自动扩展大小的关键就是gorw()方法，及扩容。
- arrayList中removeAll(collection c)和clear()的区别就是removeAll可以删除批量指定的元素，而clear是全是删除集合中的元素。
- arrayList由于本质是数组，所以它在数据的查询方面会很快，而在插入删除这些方面，性能下降很多，有移动很多数据才能达到应有的效果。
334
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
