在日常的研发工作和个人项目中，ArrayList可以说是Java中最为常用的集合之一。同时作为Java研发工程师，不能仅仅满足于表面使用，对其中实现的逻辑和源码也需要有一定的了解。
ArrayList的基本信息属性
// 列表初始默认容量
private static final int DEFAULT_CAPACITY = 10;
// 存放元素的数组（由此可知，ArrayList的底层实现依赖的是数组）
transient Object[] elementData;
// 列表中元素的个数
private int size;
// 记录列表结构改变的次数
protected transient int modCount = 0;
// 列表最大容量（由此可见，ArrayList的最大容量是有限制的）
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
ArrayList的基本信息属性还是非常直观的，接下来就从ArrayList中的方法源码进行解析了。
以下内容都是根据ArrayList类中所写的方法从上往下进行源码解析，常用和不常用的方法都会讲解分析。
ArrayList方法源码解析
- trimToSize——将列表的总长度调整到等于元素个数
public void trimToSize() {
modCount++; // 数组结构改变次数加1
if (size < elementData.length) { // 元素个数小于列表实际总长度
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size); // 利用数组拷贝方式，调整列表长度为size
}
}
- contains——列表中是否包含指定元素
public boolean contains(Object o) {
return indexOf(o) >= 0; // 直接调用indexOf方法获取结果
}
- indexOf——返回列表中从前往后寻找第一个指定元素的位置索引
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++) // 指定元素不为空，则在列表中从前往后寻找到第一个和指定元素equals比较相等的元素，并返回它的索引
if (o.equals(elementData[i]))
return i;
}
return -1; // 如果找不到，说明列表中不包含指定元素，则返回-1
}
- lastIndexOf——返回列表中从后往前寻找第一个指定元素的位置索引
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--) // 指定元素不为空，则在列表中从后往前寻找到第一个和指定元素equals比较相等的元素，并返回它的索引
if (o.equals(elementData[i]))
return i;
}
return -1;
}
- clone——克隆并返回一个新的列表
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone(); // 克隆一个与旧的完全一致的新列表
v.elementData = Arrays.copyOf(elementData, size); // 克隆方法可能存在延时，此处将克隆后的新列表中的数组更换为最新数组
v.modCount = 0; // 克隆后的新列表更改结构次数为0
return v;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
- toArray——将列表中的元素复制到新的数组中，并返回
public Object[] toArray() {
return Arrays.copyOf(elementData, size); // 调用数组工具类的拷贝方法，没什么特别
}
- toArray——将列表中的元素复制到新的数组中，并返回
public <T> T[] toArray(T[] a) {
if (a.length < size) // 指定数组的长度小于列表中的元素个数
return (T[]) Arrays.copyOf(elementData, size, a.getClass()); // 返回新的数组
System.arraycopy(elementData, 0, a, 0, size); // 否则，将列表元素填充到指定数组中，并返回
if (a.length > size)
a[size] = null;
return a;
}
- get——获取列表中指定元素
public E get(int index) {
rangeCheck(index); // 检查指定索引是否合法
return elementData(index); // 返回指定索引的元素
}
private void rangeCheck(int index) {
if (index >= size) // 指定索引大于等于元素个数，则抛出异常
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
E elementData(int index) {
return (E) elementData[index]; // 返回数组中指定索引元素
}
- set——将指定索引位置的元素改为指定元素
public E set(int index, E element) {
rangeCheck(index); // 指定索引是否合法
E oldValue = elementData(index); // 获取旧值
elementData[index] = element; // 替换新值
return oldValue; // 返回旧值
}
- add——添加元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 确认当前列表容量可以存放下一个元素，若不能则扩容
elementData[size++] = e; // 添加元素
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity; // 返回当前列表能够存放下所有元素最小的容量
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0) // 最小容量大于当前列表数组长度
grow(minCapacity); // 数组扩容
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1); // 新的数组长度为旧数组长度的1.5倍
if (newCapacity - minCapacity < 0) // 新长度仍然小于最小长度
newCapacity = minCapacity; // 则新长度为最小长度
if (newCapacity - MAX_ARRAY_SIZE > 0) // 新长度已经大于列表中数组指定最大长度
newCapacity = hugeCapacity(minCapacity); // 极限扩容
elementData = Arrays.copyOf(elementData, newCapacity); // 替换新的数组
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // 最小容量小于0，说明已经超过整数的范围，溢出了
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; // 极限扩容
}
- add——添加元素到指定索引位置
public void add(int index, E element) {
rangeCheckForAdd(index); // 检查指定索引是否合法
ensureCapacityInternal(size + 1); // 确认当前列表容量可以存放下一个元素，若不能则扩容
System.arraycopy(elementData, index, elementData, index + 1,
size - index); // 利用数组拷贝的方式，将指定索引及其后面的元素都往后移动一个位置
elementData[index] = element; // 将新元素替换指定索引元素
size++;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0) // 指定索引大于列表元素数量，或者小于0，则抛出异常
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
- 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; // 最后一个重复元素置为空
return oldValue;
}
- 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++) // 指定元素不为空，数组从前往后寻找到第一个与指定元素equals比较想等的元素，删除该元素
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false; // 数组中不存在指定元素，返回false
}
private void fastRemove(int index) { // 该方法和删除指定索引位置元素基本一致，在此不赘述
modCount++;
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
}
- clear——清空列表
public void clear() {
modCount++;
for (int i = 0; i < size; i++)
elementData[i] = null; // 所有元素赋值为空
size = 0;
}
- addAll——将集合c中的元素全部添加进列表中
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // 确认数组容量
System.arraycopy(a, 0, elementData, size, numNew); // 利用拷贝将集合c中的元素添加进列表
size += numNew;
return numNew != 0;
}
- addAll——将集合c中的元素全部插入列表指定索引位置
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index); // 检查索引是否合法
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // 确认数组容量
int numMoved = size - index;
if (numMoved > 0) // 列表中的元素个数大于指定索引，说明插入位置在列表元素中间
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved); // 利用数组拷贝将指定索引及其后面的元素往后移动numNew个位置
System.arraycopy(a, 0, elementData, index, numNew); // 将集合c中的元素按顺序覆盖列表中从指定索引及其后面的元素
size += numNew;
return numNew != 0;
}
- removeRange——删除指定范围的元素
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved); // 利用数组拷贝将列表从toIndex索引位置到末尾的元素，从fromIndex索引位置开始覆盖
// clear to let GC do its work
int newSize = size - (toIndex-fromIndex); // 则newSize之后的元素已经无用，全部置空
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}
- removeAll——从列表中删除指定的集合中包含的所有元素
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c); // 检查集合c是否为空
return batchRemove(c, false); // 批量删除
}
public static <T> T requireNonNull(T obj) {
if (obj == null) // obj为空，抛出异常
throw new NullPointerException();
return obj;
}
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++)
// 当complement为true，若列表中的元素不存在集合c当中，则不操作；若列表中的元素存在于集合c中，则将钙元素往前覆盖（只保留集合c中指定的元素）
// 当complement为false，若列表中的元素存在集合c当中，则不操作；若列表中的元素不存在集合c中，则将该元素往前覆盖（删除集合c中的指定的元素）
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
if (r != size) { // 正常来说，r都会等于size，除非出现异常，上面的遍历提前结束了。此时需要将剩下未经历过循环的元素，往前移动，覆盖掉w索引位置及其之后的元素
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) { // w不等于size，说明从w索引位置往后都是无用元素
for (int i = w; i < size; i++) // 遍历置空
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
- retainAll——保留列表中包含在指定集合中的元素。换句话说，就是从列表中删除所有不包含在指定集合中的元素。
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c); // 检查集合c是否为空
return batchRemove(c, true); // 批量删除
}
以上的方法源码解析，基本上包含了平时工作时使用的ArrayList的方法。那么除了以上的基本方法，最后还有ArrayList的迭代器，我们再来看一下。
public Iterator<E> iterator() {
return new Itr(); // 可以看到ArrayList获取迭代器的方式是新建一个Itr类的实例对象
}
对于迭代器，这里只对常用的方法进行源码分析。其他不常用的方法，就不做太多的解释了，各位有兴趣就去研究下吧。
private class Itr implements Iterator<E> {
int cursor; // 迭代器中指向下一个元素的索引
int lastRet = -1; // 最后一次调用next方法返回的元素的索引。默认为-1
int expectedModCount = modCount;
Itr() {}
public boolean hasNext() {
return cursor != size; // 只要指向下一个元素的索引不等于size，说明下一个元素不为空
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification(); // 检查迭代器是否与列表的版本一致
int i = cursor;
if (i >= size) // 指向下一个的元素的索引大于等于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) // lastRet小于0，说明没有调用过next方法，指针处于初始位置，无法删除，抛出错误
throw new IllegalStateException();
checkForComodification(); // 检查迭代器是否与列表的版本一致
try {
ArrayList.this.remove(lastRet); // 调用外部ArrayList类的remove方法删除lastRet索引位置的元素
cursor = lastRet; // 将删除元素的索引赋值给指向下一个元素的索引（因此删除元素后会将删除索引位置之后的元素往前移动一位）
lastRet = -1; // 重新初始化为-1。（每次删除完元素后，lastRet都会重新赋值。如果单独调用迭代器的remove方法，就会报错。因此remove方法一般都是搭配着next方法一起使用）
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount) // 迭代器与列表的数组结构改变次数不相等，说明版本不一致，抛出异常
throw new ConcurrentModificationException();
}
}
扫一扫
218
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
