ArrayList 源码分析(含扩容机制分析)

ArrayList 源码分析(含扩容机制分析)

1. ArrayList 概述

1.1 List 是什么?

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

1.2 ArrayList 是什么?

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

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

1.3 顺序表的优缺点

优点

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

缺点

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

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

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

详细解释

  • 开始时,cursor 指向下标为 0 的元素,lastRet 指向下标为 -1 的元素。每次调用 next 方法,cursorlastRet 会自增 1。
  • 当突然调用 ArrayListremove 方法(而不是迭代器的 remove),会导致被删除元素后面的所有元素前移,并且 modCount 变量增加。下一次调用 next 方法时,首先会判断 modCountexpectedModCount 是否相等,若不相等,就会抛出异常。
final void checkForComodification() {
    
    
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}
3.3.2 解决方案

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

ListIteratoradd() 方法与 Iteratorremove() 方法能够安全使用的原因在于,进行添加或删除操作后,都会执行 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(),否则会导致异常。

猜你喜欢

转载自blog.csdn.net/PQ781826/article/details/143359494