ArrayList源码分析与理解

关注

原创最新推荐文章于 2026-08-19 14:54:10 发布 408 阅读 AI 写同款· GEO 优化 ›

深入解析Incapsula reese84的生成机制与绕过策略本文深入解析了Incapsula reese84的生成机制与绕过策略。reese84是一种基于客户端JavaScript挑战的Web安全防护，通过动态算法收集浏览器指纹并生成令牌Cookie。文章详细拆解了其两步验证流程，并提供了使用无头浏览器、逆向JS模拟请求以及Token维护等实战绕过方法，帮助开发者和安全研究人员应对自动化访问拦截。阅读详情

java.util.ArrayList是最常用的集合类之一，阅读它的源码有助于帮助我们正确的使用它，并且学习它的思想。
在Java中，还有其他的一些集合类，它们的关系如下图
：
（图来源：Thinking in Java ）
在源码中有一大段注释，介绍了ArrayList的相关信息，总结如下：

它是List接口的一种可变数组（Resizable-array）的实现
可以存放任何元素，包括null，可以保存重复的元素
非线程安全
可以用for-each遍历集合，但它是快速失效的。

1. ArrayList的类声明

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

RandomAccess, Cloneable, java.io.Serializable为标记接口
RandomAccess：表明其支持随机快速访问
Cloneable：标记其可以调用Object.clone()方法，并按字段复制。ArrayList重写了clone()方法。
Serializable：可以支持序列化。

2. ArrayList中的字段

    // 默认的初始化容量为10
    private static final int DEFAULT_CAPACITY = 10;
    // 空数组，当创建一个容量为0的ArrayList时
    private static final Object[] EMPTY_ELEMENTDATA = {};.
    //默认的空实例数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //元素存储在此数组里，非私有是为了方便内部类访问，使用transient,该字段不会被序列化
    transient Object[] elementData; 
    //元素的实际数量
    private int size;
    //可存储最大容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

ArrayList声明了两个空数组，DEFAULTCAPACITY_EMPTY_ELEMENTDATA用于使用无参构造器，创建未指明初始容量的集合，另一个用于创建初始容量为0的空数组，这会影响到首次向集合添加元素时的扩容。

3. 创建一个ArrayList

3.1 创建一个默认大小的ArrayList

	//1.无参构造器
	public ArrayList() {
	        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
	    }
	//2.指定初始化容量的构造器
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        }
        //如果初始为0，则将数组初始化为 EMPTY_ELEMENTDATA 
        else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
    //3. 根据给定的Collection集合创建
   	public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

如果使用无参构造器创建一个ArrayList，会初始化为DEFAULTCAPACITY_EMPTY_ELEMENTDATA这个空数组，而不是创建一个容量为DEFAULT_CAPACITY的数组，当向ArrayList里添加第一个元素时，会进行扩容，扩容后容量为DEFAULT_CAPACITY，即为10。如果当前容量无法满足需求，会自动扩容。

    //添加铁元素的方法
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);
        elementData[size++] = e;
        return true;
    }
    private void ensureCapacityInternal(int minCapacity) {
        //如果为默认创建的空数组，添加一个元素，会初始化为DEFAULT_CAPACITY：10
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }
    //根据添加元素后所需的最小容量，判断是否需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // 如果所需最小容量大于当前数组的容量，进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //右移一位，即乘以1/2，扩容到原容量1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果扩容后的容量小于所需的最小容量，则将数组扩容为所需的最小容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果扩容后大于MAX_ARRAY_SIZE，调用hugeCapacity()可以扩容到Integer.MAX_VALUE
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //将原数组的内容复制到容量为扩容后大小：newCapacity的新数组中，其最终调用的是
        //System.arraycopy方法，这是一个native方法
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

3.2 通过Arrays.asList()方法创建
实际上，Arrays.asList(T…a)返回的并不是java.util.ArrayList，而是Arrays类中的一个静态内部类，它继承了AbstractList，所以它也是一个Collection，因此可以通过java.util.ArrayList的有参构造器public ArrayList(Collection<? extends E> c)创建。
通过Arrays.asList()创建的ArrayList是一个不可变长的数组，它没有重写基类AbstractList的add(Object o)，remove(int index)等方法，调用这些方法会抛出UnsupportedOperationException。

4. ArrayList中的方法

ArrayList共有以下public方法
ArrayList的方法

4.1 向集合中添加元素
共有4个添加元素的方法

//在集合最后添加一个元素
boolean add(E e)
//从一个元素添加到指定位置
void add(int index, E element)
//将另一个集合的元素添加到末尾
boolean addAll(Collection<? extends E> c)
//将另一个集合的元素从指定位置开始添加
boolean addAll(int index, Collection<? extends E> c)

boolean addAll(int index, Collection<? extends E> c)方法的源码如下：

public boolean addAll(int index, Collection<? extends E> c) {
		//边界检查，index应在[0,size]范围
        rangeCheckForAdd(index);
        //将集合转为数组，最终通过System.arraycopy实现
        Object[] a = c.toArray();
        int numNew = a.length;
        //确认所需容量
        ensureCapacityInternal(size + numNew);  
        //确定需要移动元素的数量
        int numMoved = size - index;
        //如果需要移动元素，就把原数组从index开始，复制numMoved个元素，保存到目标数组elementData中，将原数组index后的元素一次保存在目标数组的index + numNew后。
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
        //将新添加的全部元素依次放入elementData中index到index+numNew的位置上
        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

4.2 清空集合

    public void clear() {
        modCount++;
        //引用指向null，交由gc负责回收
        for (int i = 0; i < size; i++)
            elementData[i] = null;
        size = 0;
    }

4.3 扩容
当容量不足时，会调用内部的private ensureCapacityInternal方法自动完成扩容。我们也可以进行手动扩容。

 	//手动扩容
    public void ensureCapacity(int minCapacity) {
    //如果当前数组是默认空数组，则minExpand 设为10，用户指定的容量minCapacity>10,会按用户指定的容量扩容
    //如果当前数组不是默认空数组，即数组中有元素，或创建了容量为0的list,则用户指定的容量大于0才会执行后续语句。
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            ? 0: DEFAULT_CAPACITY;
        if (minCapacity > minExpand) {
    //在ensureExplicitCapacity还会进行检查，minCapacity大于当前保存元素数组的长度才会扩容
            ensureExplicitCapacity(minCapacity);
        }
    }

4.4 缩容
ArrayList的容量是大于等于其中保存元素的数量，可以把它的容量缩减到和保存的元素数量相同，以节省内存空间。尽量确保不再向其添加元素，避免缩容再扩容这种操作。

    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

4.5 从集合中获取元素
ArrayList是基于数组实现的，可以通过索引直接取得该位置的元素，时间复杂度O(1)，ArrayList在随机访问有较好的性能，但是在中插入或移除元素，需要进行元素的移动，所以性能较差。LinkedList是由双链表实现的容器，在其中插入或移除元素性能较好，随机访问性能较差。

    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

查找某个对象在集合中的位置

    public int indexOf(Object o) {
    	//ArrayList允许加入null，并且允许重复的元素，此方法会从前向后遍历，返回第一个该元素的索引，lastIndexOf会从后向前遍历，返回该元素出现的最后位置，
        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;
    }

4.6 迭代器 iterator
ArrayList 实现了List接口，List继承Collection接口，collection继承了Iterable接口，实现Iterable接口的类都要实现一个能够返回迭代器对象Iterator的iterator();方法。Iterator接口有4个方法
Itertor
forEachRemaining 是jdk1.8中的新增方法，具有默认实现。
remove方法的默认实现会抛出UnsupportedOperationException(“remove”);。
hasNext():判断是否还有下一个元素。
next():返回下一个元素。
首先看ArrayList中对Iterable接口iterator()的实现，它返回了Itr对象，这是ArrayList的内部类，实现了Iterator接口。通过这个方法返回的迭代器是fail-fast快速失效的，并且它只能单向移动。ListIterator listIterator()返回一个双向移动的迭代器。

	public Iterator<E> iterator() {
        return new Itr();
    }

Itr的代码如下：

    private class Itr implements Iterator<E> {
        int cursor;       // 下一个待返回元素索引
        // 返回的最后的元素的索引，初始化为-1，可以理解为指向第一个元素之前
        int lastRet = -1; 
        int expectedModCount = modCount;//将预期修改计数初始化为modCount
        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
        //在获取下个元素是，会进行modCount==expectedModCount的检查，为false会抛出ConcurrentModificationException()，
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            //cursor后移
            cursor = i + 1;
            //返回元素
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
            try {
            	//移除最新返回的元素，即最后调用next()之后的那个元素
                ArrayList.this.remove(lastRet);
                //索引lastRet位置的元素已被删除，后面的元素会依次前移，下一个待返回的索引是lastRet
                cursor = lastRet;
                //最新返回的元素已不存在，设为-1
                lastRet = -1;
                //删除会修改modCount,需要同步，避免迭代器失效
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

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

在ArrayList中，modCount属性用来实现fail-fast，当一个方法会对ArrayList的数组的容量进行改变，如trimToSize，ensureExplicitCapacity，或使存储结构发生改变，如add，remove，clear，modCount都会自增，替换操作set方法没有改变结构，所以modCount不会改变。
在for-each语句中，做出会修改modCount的操作，迭代器会失效，抛出ConcurrentModificationException()。

阅读完源码之后，应该知道在什么情况下使用ArrayList集合，在什么情况下使用其他集合，记忆如何正确的使用其中的方法。

收录于