JavaArrayList源码分析（含扩容机制重点问题分析），这个回答让我错失offer

public void trimToSize() {

modCount++;

// 数组容量大于实际元素个数（例如10个元素，却有15个容量）

if (size < elementData.length) {

// 根据元素实际个数，重新最小化实例容量

elementData = (size == 0)

? EMPTY_ELEMENTDATA

Arrays.copyOf(elementData, size);

}

}

2.5 扩容方法

========================================================================

这里只是按照顺序介绍，后面还会专门针对扩容进行一个分析

/**

• 增加ArrayList实例的容量，如果有必要，确保它至少可以保存由最小容量参数指定的元素数量。

*/

public void ensureCapacity(int minCapacity) {

//如果元素数组不为默认的空，则 minExpand 的值为0，反之值为10

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);

}

}

/**

• 计算最小扩容量（被调用）

*/

private static int calculateCapacity(Object[] elementData, int minCapacity) {

// 如果元素数组为默认的空

if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

// 获取“默认的容量”和“传入参数 minCapacity ”两者之间的最大值

return Math.max(DEFAULT_CAPACITY, minCapacity);

}

return minCapacity;

}

/**

• 得到最小扩容量

*/

private void ensureCapacityInternal(int minCapacity) {

ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));

}

/**

• 判断是否需要扩容

*/

private void ensureExplicitCapacity(int minCapacity) {

modCount++;

// overflow-conscious code

// 如果最小容量比数组的长度还大

if (minCapacity - elementData.length > 0)

// 就调用grow方法进行扩容

grow(minCapacity);

}

/**

• 要分配的最大数组大小

*/

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**

• ArrayList 扩容的核心方法

*/

private void grow(int minCapacity) {

// 将当前元素数组长度定义为 oldCapacity 旧容量

int oldCapacity = elementData.length;

// 新容量更新为旧容量的1.5倍

// oldCapacity >> 1 为按位右移一位，相当于 oldCapacity 除以2的1次幂

int newCapacity = oldCapacity + (oldCapacity >> 1);

// 然后检查新容量是否大于最小需要容量，若还小，就把最小需要容量当作数组的新容量

if (newCapacity - minCapacity < 0)

newCapacity = minCapacity;

// 再检查新容量是否超出了ArrayList 所定义的最大容量

if (newCapacity - MAX_ARRAY_SIZE > 0)

// 若超出，则调用hugeCapacity()

newCapacity = hugeCapacity(minCapacity);

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;

}

2.6 常规方法

========================================================================

/**

• 返回元素数量

*/

public int size() {

return size;

}

/**

• 此列表元素数量为 0 则返回 true

*/

public boolean isEmpty() {

return size == 0;

}

/**

• 此列表含有指定元素，则返回true

*/

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 {

// 本质就是循环 equals 比对

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 {

// 逆向循环 equals 比对

for (int i = size-1; i >= 0; i–)

if (o.equals(elementData[i]))

return i;

}

return -1;

}

/**

• 返回 ArrayList 实例的浅拷贝

*/

public Object clone() {

try {

ArrayList<?> v = (ArrayList<?>) super.clone();

// 实现数组的复制，参数为被复制者的参数

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(e);

}

}

/**

• 返回一个包含此列表中所有元素的数组（理解为将集合转为数组即可）

*/

public Object[] toArray() {

return Arrays.copyOf(elementData, size);

}

/**

• 将list转化为你所需要类型的数组，然后返回

*/

@SuppressWarnings(“unchecked”)

public T[] toArray(T[] a) {

if (a.length < size)

// Make a new array of a’s runtime type, but my contents:

return (T[]) Arrays.copyOf(elementData, size, a.getClass());

// 复制用法，下面专题会讲解此内容

System.arraycopy(elementData, 0, a, 0, size);

if (a.length > size)

a[size] = null;

return a;

}

// Positional Access Operations

@SuppressWarnings(“unchecked”)

E elementData(int index) {

return (E) elementData[index];

}

/**

• 返回此列表中指定位置的元素。

*/

public E get(int index) {

// index 范围检查

rangeCheck(index);

return elementData(index);

}

/**

• 用指定的元素替换此列表中指定位置的元素。

*/

public E set(int index, E element) {

// index 范围检查

rangeCheck(index);

// 根据 index 找到想替换的旧元素

E oldValue = elementData(index);

// 替换元素

elementData[index] = element;

return oldValue;

}

/**

• 将指定的元素追加到此列表的末尾。

*/

public boolean add(E e) {

// 确认 list 容量，尝试容量加 1，看看有无必要扩容

ensureCapacityInternal(size + 1); // Increments modCount!!

// 赋值

elementData[size++] = e;

return true;

}

/**

• 在此列表中的指定位置插入指定的元素

• 再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。

*/

public void add(int index, E element) {

// 调用 rangeCheckForAdd 对 index 进行范围检查

rangeCheckForAdd(index);

// 保证容量足够

ensureCapacityInternal(size + 1); // Increments modCount!!

// 自己复制自己，然后达到 index 之后全部元素向后挪一位的效果

System.arraycopy(elementData, index, elementData, index + 1,

size - index);

// 然后将 index 赋值为指定的元素

elementData[index] = element;

size++;

}

/**

• 移除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。

*/

public E remove(int index) {

// 调用 rangeCheckForAdd 对 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; // clear to let GC do its work

return oldValue;

}

/**

• 从集合中移除第一次出现的指定元素

*/

public boolean remove(Object o) {

if (o == null) {

for (int index = 0; index < size; index++)

if (elementData[index] == null) {

fastRemove(index);

return true;

}

} else {

// 也很简单，就是一个循环 equals 判断，然后移除

for (int index = 0; index < size; index++)

if (o.equals(elementData[index])) {

fastRemove(index);

return true;

}

}

return false;

}

/*

• 跳过范围检查的删除方式，与remove(Object o)相同

*/

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

}

/**

• 从列表中删除所有元素。

*/

public void clear() {

modCount++;

// clear to let GC do its work

for (int i = 0; i < size; i++)

// 元素全部设为 null

elementData[i] = null;

// 长度设为 0

size = 0;

}

/**

• 按指定集合的Iterator返回的顺序

• 将指定集合中的所有元素追加到此列表的末尾。

*/

public boolean addAll(Collection<? extends E> c) {

// 转为数组

Object[] a = c.toArray();

// 拿到待添加指定数组的长度

int numNew = a.length;

// 确认 list 容量，尝试容量加上 numNew，看看有无必要扩容

ensureCapacityInternal(size + numNew); // Increments modCount

// 利用 arraycopy 指定数组a的元素追加到当前数组 elementData 后

System.arraycopy(a, 0, elementData, size, numNew);

size += numNew;

return numNew != 0;

}

/**

• 按指定集合的Iterator返回的顺序

• 将指定集合中的所有元素添加到此列表中，从指定位置开始

*/

public boolean addAll(int index, Collection<? extends E> c) {

rangeCheckForAdd(index);

Object[] a = c.toArray();

int numNew = a.length;

ensureCapacityInternal(size + numNew); // Increments modCount

// 计算需要移动的元素

int numMoved = size - index;

if (numMoved > 0)

// 实现元素指定位置的插入，本质还是 arraycopy 自身

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);

// clear to let GC do its work

int newSize = size - (toIndex-fromIndex);

for (int i = newSize; i < size; i++) {

elementData[i] = null;

}

size = newSize;

}

/**

• 检查给定的索引是否在范围内。

*/

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) {

re

《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》

【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享

turn "Index: “+index+”, Size: "+size;

}

/**

• 从此列表中删除指定集合中包含的所有元素。

*/

public boolean removeAll(Collection<?> c) {

Objects.requireNonNull©;

return batchRemove(c, false);

}

/**

• 仅保留此列表中包含在指定集合中的元素。即删掉没有的部分

*/

public boolean retainAll(Collection<?> c) {

Objects.requireNonNull©;

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++)

// 通过循环判断数组中有没有指定数组中的每一个值，complement 是参数传递的

if (c.contains(elementData[r]) == complement)

// 就将原数组的r位置的数据覆盖掉w位置的数据

// r位置的数据不变，并其w自增，r自增

// 否则，r自增，w不自增

// 本质：把需要移除的数据都替换掉，不需要移除的数据前移

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) {

// clear to let GC do its work

for (int i = w; i < size; i++)

elementData[i] = null;

modCount += size - w;

size = w;

modified = true;

}

}

return modified;

}

// writeObject readObject 序列化相关的省略

/**

• 列表迭代器：List集合特有的迭代器

*/

public ListIterator listIterator(int index) {

if (index < 0 || index > size)

throw new IndexOutOfBoundsException("Index: "+index);

return new ListItr(index);

}

public ListIterator listIterator() {

return new ListItr(0);

}

// foreach 遍历等同于 iterator

public Iterator iterator() {

return new Itr();

}

private class Itr implements Iterator {

// 下一个要访问的元素下标

int cursor;

// 上一个要访问的元素下标

int lastRet = -1;

// 代表对 ArrayList 修改次数的期望值，初始值为 modCount

int expectedModCount = modCount;

Itr() {}

// 下标如果

public boolean hasNext() {

return cursor != size;

}

/**

• 刚开始cursor = 0，lastRet = -1

• 整个过程结束 cursor 和 lastRet 都会自增 1

*/

@SuppressWarnings(“unchecked”)

public E next() {

// 跳转本质是判断 modCount 是否等于 expectedModCount

checkForComodification();

int i = cursor;

// 判断 cursor 是否超过集合大小和数组长度

if (i >= size)

throw new NoSuchElementException();

Object[] elementData = ArrayList.this.elementData;

if (i >= elementData.length)

throw new ConcurrentModificationException();

cursor = i + 1;

// 将 cursor 赋值给 lastRet，然后把此下标处的元素返回

return (E) elementData[lastRet = i];

}

public void remove() {

// 先判断 lastRet 的值是否小于 0

if (lastRet < 0)

throw new IllegalStateException();

// 跳转本质是判断 modCount 是否等于 expectedModCount

checkForComodification();

try {

// 直接调用 ArrayList 的 remove 方法删除下标为 lastRet 的元素

ArrayList.this.remove(lastRet);

cursor = lastRet;

lastRet = -1;

expectedModCount = modCount;

} catch (IndexOutOfBoundsException ex) {

throw new ConcurrentModificationException();

}

}

// forEachRemaining 略

final void checkForComodification() {

if (modCount != expectedModCount)

throw new ConcurrentModificationException();

}

}

3. 重点内容分析

==========================================================================

3.1 扩容机制再分析

===========================================================================

3.1.1 ArrayList 是如何被初始化的

========================================================================================

ArrayList 提供了 1 个无参构造和 2 个带参构造来初始化 ArrayList ，我们在创建 ArrayList 时，经常使用无参构造的方式，其本质就是初始化了一个空数组，直到向数组内真的添加元素的时候才会真的去分配容量。例如：向数组中添加第一个元素，数组容量扩充为 10

补充：JDK7 无参构造 初始化 ArrayList 对象时，直接创建了长度是 10 的 Object[] 数组elementData

3.1.2 扩容机制流程分析（无参构造为例）

======================================================================================

3.1.2.1 add()

=============================================================================

一般来说，都是通过 add 方法触发扩容机制，我们拿最简单的尾部追加的 add() 方法举例

/**

• 将指定的元素追加到此列表的末尾。

*/

public boolean add(E e) {

// 确认 list 容量，尝试容量加 1，看看有无必要扩容

ensureCapacityInternal(size + 1); // Increments modCount!!

// 赋值

elementData[size++] = e;

return true;

}

核心要点就这一句 ensureCapacityInternal(size + 1);

3.1.2.2 ensureCapacityInternal()

================================================================================================

追踪进去

/**

• 得到最小扩容量

*/

private void ensureCapacityInternal(int minCapacity) {

ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));

}

方法内调用了 ensureExplicitCapacity() 方法，参数是 calculateCapacity(elementData, minCapacity)

先来分析一下这个参数的结果是什么，聚焦到 calculateCapacity() 方法中去

3.1.2.3 calculateCapacity()

===========================================================================================

/**

• 计算最小扩容量（被调用）

*/

private static int calculateCapacity(Object[] elementData, int minCapacity) {

// 如果元素数组为默认的空

if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

// 获取“默认的容量”和“传入参数 minCapacity ”两者之间的最大值

return Math.max(DEFAULT_CAPACITY, minCapacity);

}

return minCapacity;

}

也很简单，就是为了计算出一个最小扩容量，当元素为初次初始化时，数组还没进过扩容，是一个空数组，所以会走 if 这个判断，而且当时传入的 size + 1 也就是 minCapacity 的值为 0 + 1 = 1 ，经过一个取大值的操作，与默认的 DEFAULT_CAPACITY 进行比对，自然返回的就是 10。

如果数组已经不是为空了，就直接返回一个 minCapacity （size + 1）就可以了

3.1.2.4 ensureExplicitCapacity

==============================================================================================

ensureCapacityInternal 方法内调用了 ensureExplicitCapacity(参数已经计算出来了) 方法

继续去看它

/**

• 判断是否需要扩容

*/

private void ensureExplicitCapacity(int minCapacity) {

modCount++;

// overflow-conscious code

// 如果最小容量比数组的长度还大

if (minCapacity - elementData.length > 0)

// 就调用grow方法进行扩容

grow(minCapacity);

}

此方法的核心就是 if 判断这个数组需不需要扩容，可以分为三种情况

• add 第 1 个元素时：此时数组还只是一个被初始化过的空数组，minCapacity 经过calculateCapacity 计算会返回 DEFAULT_CAPACITY 的默认值 10，而 elementData.length 也自然是 0，所以 minCapacity - elementData.length > 0 是成立的，直接进入 grow(minCapacity); 开始扩容。

• add 第 2 到 10 个元素的时候（以 2 举例）：此时 minCapacity = size + 1 = 1 + 1 = 2 ，而 elementData.length 已经在添加第 1 个元素后等于 10 了。所以 minCapacity - elementData.length > 0 就不成立了，所以不会进入grow(minCapacity); ，也不会扩容添加第 3 … 10 个元素的时候，都是一样的。

• add 第 11 个元素的时候，minCapacity 变成了 11，比 10 还要大，所以又一次进去扩容了

3.1.2.5 grow()

==============================================================================

这里是真正去执行扩容逻辑的代码

/**

• 要分配的最大数组大小

*/

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**

• ArrayList 扩容的核心方法

*/

private void grow(int minCapacity) {

// 将当前元素数组长度定义为 oldCapacity 旧容量

int oldCapacity = elementData.length;

// 新容量更新为旧容量的1.5倍

// oldCapacity >> 1 为按位右移一位，相当于 oldCapacity 除以2的1次幂

int newCapacity = oldCapacity + (oldCapacity >> 1);

// 然后检查新容量是否大于最小需要容量，若还小，就把最小需要容量当作数组的新容量

if (newCapacity - minCapacity < 0)

newCapacity = minCapacity;

// 再检查新容量是否超出了ArrayList 所定义的最大容量

if (newCapacity - MAX_ARRAY_SIZE > 0)

// 若超出，则调用hugeCapacity()

newCapacity = hugeCapacity(minCapacity);

elementData = Arrays.copyOf(elementData, newCapacity);

}

扩容的核心就是这句： int

newCapacity = oldCapacity + (oldCapacity >> 1);

本质就是扩容 1.5 倍，而且其中使用了移位运算，这里从计算的角度上来看，相当于 oldCapacity 除以 2 的 1 次幂（偶数除以 2 刚好除尽，奇数丢掉小数部分）。使用按位右移，效率会高很多

按位右移运算符：最高位为 0，左边补齐 0，最高位是 1，左边补齐 1

• 快速计算：把 >> 左边的数据 除以 2 的移动次幂：例如 -24 >> 2 即：-24 / 2 ^ 2 = -6

—— 此项目 【001-Java基础知识】 章节中有具体介绍

扩容后，需要对这个新容量的范围进行一个判断，不能小于最小需要容量，也不能大于定义的最大容量，分情况细细看一下（以 1 和 11 举例，是因为这两种都是刚好需要扩容的）

• add 第 1 个元素的时候，数组还为空，所以无论是 oldCapacity 还是 newCapacity 都是 0，经过第一次判断后，newCapacity = minCapacity 执行了，此时 newCapacity 为 10，第二个判断不会进入，它不可能大于数组的最大容量。

• add 第 11 个元素的时候，oldCapacity 为 10，newCapacity = 10 + 10/2 = 15，大于 minCapacity = 11，第一个判断不会进入，同时它肯定也没有大于数组最大 size，不会进入 。数组容量此时就扩为 15，add 方法中会返回一个 true，size 也增加成 11。

• 后面都是同样的道理 …

3.1.2.6 hugeCapacity()

======================================================================================

这个方法就是在 newCapacity 大于 MAX_ARRAY_SIZE 的时候，开始判断 minCapacity 和 MAX_ARRAY_SIZE 谁大，然后赋予不同的值。

/**

• 比较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;

}

3.2 System.arraycopy() 和 Arrays.copyOf() 复制方法

=============================================================================================================

在前面的方法中，大量的用到了这两个方法，基本但凡涉及到元素移动的都会用到。

3.2.1 System.arraycopy()

========================================================================================

拿 add 方法中的举例

/**

• 在此列表中的指定位置插入指定的元素

• 再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。

*/

public void add(int index, E element) {

// 调用 rangeCheckForAdd 对 index 进行范围检查

rangeCheckForAdd(index);

// 保证容量足够

ensureCapacityInternal(size + 1); // Increments modCount!!

// 自己复制自己，然后达到 index 之后全部元素向后挪一位的效果

System.arraycopy(elementData, index, elementData, index + 1,

size - index);

// 然后将 index 赋值为指定的元素

elementData[index] = element;

size++;

}