ArrayList 源码分析（含扩容机制分析）

1. ArrayList 概述

1.1 List 是什么？

List 在 Collection 中充当有序的集合（也称为序列）。实现该接口的用户可以精确控制元素的插入位置，支持通过整数索引访问元素，并在列表中搜索元素。与 Set 不同，列表通常允许重复的元素。

1.2 ArrayList 是什么？

ArrayList 的底层实现是一个数组，依赖扩容机制实现动态增长。它的特点包括：

查询速度快
增删操作相对较慢
线程不安全
效率高

1.3 顺序表的优缺点

优点：

逻辑与物理顺序一致，能够快速按下标存取元素。
不需额外存储空间表示元素之间的逻辑关系。

缺点：

长度需初始定义，难以确定存储空间容量，扩容降低效率。
插入和删除操作需移动大量元素，效率较低。

1.4 时间复杂度证明

读取：时间复杂度为 O(1)。
插入和删除：
- 最好情况（末尾插入）：O(1)
- 最坏情况（开头插入）：O(n)
- 平均情况：O(n)

总结：ArrayList 更适合处理元素个数相对稳定且查询频繁的情况。

2. 核心源码分析

2.1 类声明

ArrayList 继承了 AbstractList 类并实现了多个接口：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    
     
    // 源码具体内容... 
}

RandomAccess：标志接口，表示支持快速随机访问。
Cloneable：支持克隆操作。
java.io.Serializable：支持序列化。

2.2 类成员

transient Object[] elementData;：存储元素的数组。

// 序列化自动生成的一个码，用来在正反序列化中验证版本一致性。
private static final long serialVersionUID = 8683452581122892189L;

/**
 * 默认初始容量大小为10
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 指定 ArrayList 容量为0（空实例）时，返回此空数组
 */
private static final Object[] EMPTY_ELEMENTDATA = {
    
    };

/**
 * 与 EMPTY_ELEMENTDATA 的区别是，它是默认返回的，而前者是用户指定容量为 0 才返回
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
    
    };

/**
 * 具体存放元素的数组
 * 保存添加到 ArrayList 中的元素数据（第一次添加元素时，会扩容到 DEFAULT_CAPACITY = 10 ） 
 */
transient Object[] elementData; // non-private to simplify nested class access

/**
 * ArrayList 实际所含元素个数（大小）
 */
private int size;

2.3 构造方法

无参构造器初始化容量为 0，添加第一个元素（扩充为10）。
带参构造器根据指定容量初始化。

/**
 * 带参构造函数，参数为用户指定的初始容量
 */
public ArrayList(int initialCapacity) {
    
    
    if (initialCapacity > 0) {
    
    
        // 参数大于0，创建 initialCapacity 大小的数组
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
    
    
        // 参数为0，创建空数组（成员中有定义）
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
    
    
        // 其他情况，直接抛异常
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

/**
 * 默认无参构造函数，初始值为 0
 * 也说明 DEFAULT_CAPACITY = 10 这个容量
 * 不是在构造函数初始化的时候设定的（而是在添加第一个元素的时候）
 */
public ArrayList() {
    
    
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * 构造一个包含指定 collection 的元素的列表
 * 这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
 */
public ArrayList(Collection<? extends E> c) {
    
    
    // 将给定的集合转成数组
    elementData = c.toArray();
    // 如果数组长度不为 0
    if ((size = elementData.length) != 0) {
    
    
        // elementData 如果不是 Object 类型的数据，返回的就不是 Object 类型的数组
        if (elementData.getClass() != Object[].class)
            // 将不是 Object 类型的 elementData 数组，赋值给一个新的 Object 类型的数组
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
    
    
        // 数组长度为 0 ，用空数组代替
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

2.4 扩容方法

扩容方法会在元素添加超过当前容量时被调用。

/**
 * 增加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.5 常规方法

/**
 * 返回元素数量
 */
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> 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) {
    
    
    return "Index: "+index+", Size: "+size;
}

/**
 * 从此列表中删除指定集合中包含的所有元素。
 */
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++)
            // 通过循环判断数组中有没有指定数组中的每一个值，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<E> listIterator(int index) {
    
    
    if (index < 0 || index > size)
        throw new IndexOutOfBoundsException("Index: "+index);
    return new ListItr(index);
}


public ListIterator<E> listIterator() {
    
    
    return new ListItr(0);
}

// foreach 遍历等同于 iterator
public Iterator<E> iterator() {
    
    
    return new Itr();
}


private class Itr implements Iterator<E> {
    
    
    // 下一个要访问的元素下标
    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 提供一个无参构造和两个带参构造。无参构造会初始化一个空数组，添加第一个元素时扩容为 10。

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

3.1.2 扩容机制流程分析

add() 方法：通常通过 add() 方法触发扩容机制。

/**
 * 将指定的元素追加到此列表的末尾。
 */
public boolean add(E e) {
      
      
    // 确认 list 容量，尝试容量加 1，看看有无必要扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 赋值
    elementData[size++] = e;
    return true;
}

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

ensureCapacityInternal()：调用 ensureExplicitCapacity()，并传入计算出的容量。

/**
 * 得到最小扩容量
 */
private void ensureCapacityInternal(int minCapacity) {
      
      
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

calculateCapacity()：计算最小扩容量。如果是空数组，返回 10。

/**
 * 计算最小扩容量（被调用）
 */
private static int calculateCapacity(Object[] elementData, int minCapacity) {
      
      
     // 如果元素数组为默认的空
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
      
      
        // 获取“默认的容量”和“传入参数 minCapacity ”两者之间的最大值
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

ensureExplicitCapacity：判断是否需要扩容。

第一个元素时需要扩容。
之后的元素在容量足够时不再扩容。

/**
 * 判断是否需要扩容
 */
private void ensureExplicitCapacity(int minCapacity) {
      
      
    modCount++;
    // overflow-conscious code
    // 如果最小需要的容量比当前数组的长度还大
    if (minCapacity - elementData.length > 0)
        // 就调用grow方法进行扩容
        grow(minCapacity);
}

grow()：执行扩容，通常扩容为 1.5 倍。

/**
 * 要分配的最大数组大小
 */
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);

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()：用于元素移动。

/**
 * 在此列表中的指定位置插入指定的元素
 * 再将从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++;
}

/**
 * 数组复制
 * 	src - 源数组。
 * 	srcPos - 源数组中的起始位置。
 * 	dest - 目标数组。 
 * 	destPos - 目的地数据中的起始位置。 
 * 	length - 要复制的数组元素的数量。
 */
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

Arrays.copyOf()：用于扩容。

public static void main(String[] args) {
      
      

    int[] arr1 = {
      
      1, 2, 3, 4, 5};
    int[] arr2 = Arrays.copyOf(arr1, 5);
    int[] arr3 = Arrays.copyOf(arr1, 10);

    System.out.println(Arrays.toString(arr1));
    System.out.println(Arrays.toString(arr2));
    System.out.println(Arrays.toString(arr3));
}

运行结果：
[1, 2, 3, 4, 5]

[1, 2, 3, 4, 5]

[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

3.3 并发修改异常问题探索

public static void main(String[] args) {
    
    
    // 创建集合对象
    List list = new ArrayList();

    // 存储元素
    list.add("I");
    list.add("love");
    list.add("you");

    Iterator it = list.iterator();
    while (it.hasNext()) {
    
    
        String s = (String) it.next();
        if ("love".equals(s)) {
    
    
            list.add("❤");
        }
        System.out.println(s);
    }
}

//运行结果(节选)
Exception in thread "main" java.util.ConcurrentModificationException

使用增强for或者迭代器遍历集合的时候，如果对集合进行 list的 remove 和 add 操作，会出现 ConcurrentModificationException 并发修改异常的问题。

3.3.1 原因解释

当我们对集合进行遍历时，会获取当前集合的迭代对象：

// List为例，获取集合的迭代对象
Iterator<String> it = list.iterator();

这个迭代对象中封装了迭代器的方法与集合本身的一些方法。当我们在迭代中使用集合本身的 add 或 remove 方法时，会产生 ConcurrentModificationException 异常。通俗来说，在判断 equals 成功后，执行了集合的 add 或 remove 方法，导致集合中元素的添加或删除发生变化，但迭代器并不知情，因此会报错。

详细解释

开始时，cursor 指向下标为 0 的元素，lastRet 指向下标为 -1 的元素。每次调用 next 方法，cursor 和 lastRet 会自增 1。
当突然调用 ArrayList 的 remove 方法（而不是迭代器的 remove），会导致被删除元素后面的所有元素前移，并且 modCount 变量增加。下一次调用 next 方法时，首先会判断 modCount 和 expectedModCount 是否相等，若不相等，就会抛出异常。

final void checkForComodification() {
    
    
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

3.3.2 解决方案

虽然 Iterator 迭代器没有提供添加功能，但其子接口 ListIterator 却拥有 add、set 和 remove 方法。在这里，我们仅演示 add 方法，而 remove 方法仍然使用 Iterator 的 remove()。

ListIterator 的 add() 方法与 Iterator 的 remove() 方法能够安全使用的原因在于，进行添加或删除操作后，都会执行 expectedModCount = modCount 的赋值操作，这相当于告诉迭代器进行了修改操作，从而保持了状态一致性。

3.3.2.1 使用迭代器的 `remove` 方法

通过迭代器的 remove 方法进行删除，避免抛出异常。

public static void main(String[] args) {
    
    
    // 创建集合对象
    List list = new ArrayList();
    
    // 存储元素
    list.add("I");
    list.add("love");
    list.add("you");

    ListIterator lit = list.listIterator();
    while (lit.hasNext()) {
    
    
        String s = (String) lit.next();
        if ("love".equals(s)) {
    
    
            // add 、remove 都是可以的
            lit.add("❤");
        }
        System.out.print(s + " ");
    }
    
    System.out.println();

    for (Object l : list){
    
    
    	System.out.print(l + " ");
    }
}

//运行结果
I love you
I love ❤ you

3.3.2.2 使用 `ListIterator` 进行添加和删除

ListIterator 支持在遍历时进行添加和删除操作，能够安全地避免异常。

public static void main(String[] args) {
    
    
    // 创建集合对象
    List<String> list = new ArrayList<>();

    // 存储元素
    list.add("I");
    list.add("love");
    list.add("you");

    // 使用 ListIterator 遍历
    ListIterator<String> lit = list.listIterator();
    while (lit.hasNext()) {
    
    
        String s = lit.next();
        if ("love".equals(s)) {
    
    
            lit.add("❤"); // 安全地添加元素
        }
        System.out.print(s + " ");
    }
}

// 运行结果
// I love ❤ you

3.3.2.3 集合遍历元素，集合修改元素（普通for）

public static void main(String[] args) {
    
    
    //创建集合对象
    List list = new ArrayList();

    //存储元素
    list.add("I");
    list.add("love");
    list.add("you");

    for (int x = 0; x < list.size(); x++){
    
    
        String s = (String)list.get(x);
        if ("love".equals(s)){
    
    
            list.add("❤");
        }
        System.out.print(s + " ");
    }
}

//运行结果
I love you ❤

3.3.3 iterator.remove() 的弊端

Iterator 只支持 remove() 方法，不能 add。
remove() 方法的使用限制：
- 在调用 remove() 方法之前，必须先调用 next() 方法。这是因为 remove() 会依赖于 next() 方法返回的当前元素。如果没有调用 next()，lastRet 的值将仍为 -1，调用 remove() 时会抛出 IllegalStateException
remove() 的调用限制：
next() 方法调用后只能调用一次 remove()。调用 remove() 会将 lastRet 重新初始化为 -1，这意味着在再次调用 next() 之前，不能再调用 remove()，否则会导致异常。
ls(s)) {
lit.add(“❤”); // 安全地添加元素
}
System.out.print(s + " ");
}
}

// 运行结果
// I love ❤ you


##### 3.3.2.3 集合遍历元素，集合修改元素（普通for）

```java
public static void main(String[] args) {
    //创建集合对象
    List list = new ArrayList();

    //存储元素
    list.add("I");
    list.add("love");
    list.add("you");

    for (int x = 0; x < list.size(); x++){
        String s = (String)list.get(x);
        if ("love".equals(s)){
            list.add("❤");
        }
        System.out.print(s + " ");
    }
}

//运行结果
I love you ❤

3.3.3 iterator.remove() 的弊端

Iterator 只支持 remove() 方法，不能 add。
remove() 方法的使用限制：
- 在调用 remove() 方法之前，必须先调用 next() 方法。这是因为 remove() 会依赖于 next() 方法返回的当前元素。如果没有调用 next()，lastRet 的值将仍为 -1，调用 remove() 时会抛出 IllegalStateException
remove() 的调用限制：
next() 方法调用后只能调用一次 remove()。调用 remove() 会将 lastRet 重新初始化为 -1，这意味着在再次调用 next() 之前，不能再调用 remove()，否则会导致异常。