《JAVA1.8源码分析》：ArrayList

最新推荐文章于 2025-12-01 17:12:07 发布

原创最新推荐文章于 2025-12-01 17:12:07 发布 · 222 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java #java源码 #ArrayList

java源码分析专栏收录该内容

5 篇文章

订阅专栏

本文深入剖析了Java 1.8中ArrayList的实现原理，包括其继承体系、内部属性、构造函数、add、addAll、remove、get、set及clear等核心方法的实现细节。

《JAVA1.8源码分析》：ArrayList

继承体系

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

ArrayList实现了AbstractList接口，并继承了list接口，同时实现了RandomAccess，Cloneable，Serializable接口，使其具有随机访问，复制和序列化的功能。

属性

//初始容量大小为10
1. private static final int DEFAULT_CAPACITY = 10;
//共享空常量数组
2. private static final Object[] EMPTY_ELEMENTDATA = {};
//共享空常量数组（与EMPTY_ELEMENTDATA的区别在于当第一个元素被加入进来的时候它知道如何扩张）
3. private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//存储ArrayList中的元素(从这个可以看出，ArrayList是底层是借组于数组来实现的。)
4. transient Object[] elementData;
//存储的元素个数
5. private int size;

构造函数
ArrayList具有三个构造函数

//1.无参数构造函数（elementData数据直接复制为共享空常量数组）
public ArrayList() {
       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
   }

构造一个初始容量为 10 的空列表。

即当我们不提供参数而new一个对象时，底层的数组就是直接用长度为10的空常量数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA进行实例化。

//2.指定容量作为参数的构造函数
public ArrayList(int initialCapacity) {
       if (initialCapacity > 0) {
           this.elementData = new Object[initialCapacity];
       } else if (initialCapacity == 0) {
           this.elementData = EMPTY_ELEMENTDATA;
       } else {
           throw new IllegalArgumentException("Illegal Capacity: "+
                                              initialCapacity);
       }
   }

从源码可以看到，就是根据参数的大小作为容量来实例化底层的数组对象，其中对参数的3中情况进行了处理。当参数小于0时，抛异常。当参数等于0时，用空的常量数组对象EMPTY_ELEMENTDATA来初始化底层数组elementData。

//3.Collection作为参数的构造函数
//3.1 将集合转换为数组（c.toArray()）并赋值给elementData
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;
        }
    }

从源码可以看到，将容器Collection转化为数组赋给数组elementData，还对Collection转化是否转化为了Object[]进行了检查判断。如果Collection为空，则就将空的常量数组对象EMPTY_ELEMENTDATA赋给了elementData；

add函数

//函数功能：将制定的元素加入到List的末尾。
public boolean add(E e) {
       //添加修改次数以及判断是否需要扩张数组长度，
       ensureCapacityInternal(size + 1);  // Increments modCount!!
       //插入数据，数据量+1
       elementData[size++] = e;
       return true;
   }

//函数功能：将制定的元素加入到List的指定位置。
public void add(int index, E element) {
       //位置有效性检查
       rangeCheckForAdd(index);
       //添加修改次数以及判断是否需要扩张数组长度，
       ensureCapacityInternal(size + 1);  // Increments modCount!!
       //完成数组自身从index开始的所有元素拷贝到index+1开始且长度为size-index的位置上。
       System.arraycopy(elementData, index, elementData, index + 1,
                        size - index);
        //插入数据                
       elementData[index] = element;
       //数据量加1
       size++;
   }

在增加数据之前都需要对数组长度进行判断，下面分析一下数据长度判断以及扩容的函数ensureCapacityInternal


private void ensureCapacityInternal(int minCapacity) {
        //如果是刚构建的ArrayList,(数据长度则取10与minCapacity的最大值)
        //调用无参构造相当于构造的一个长度为10的数组对象。
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        //数组长度不够，需要扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

//ArrayList扩容函数
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //一般情况下是扩展到原来数组长度的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
         /*下面两个if的作用为处理两种情况：
        1）第一种情况为：如果newCapacity扩展的过小。则应该至少扩张到所需的空间大小minCapacity
        2）第二种情况为：newCapacity扩张的过大，如果过大，则用Integer.MAX_VALUE来代替。*/

        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        //原来的数组中的元素复制扩展到大小为newCapacity的新数组中，并返回这个新数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

addAll函数

public boolean addAll(Collection<? extends E> c) {
        //转为数组
        Object[] a = c.toArray();
        int numNew = a.length;
        //判断是否扩容
        ensureCapacityInternal(size + numNew);  // Increments modCount
        //复制集合数组到ArrayList数组中
        System.arraycopy(a, 0, elementData, size, numNew);
        //改变长度
        size += numNew;
        return numNew != 0;
    }

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;
        //先将Array数据从复制到后面
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
        //复制集合数组到ArrayList数组中
        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

remove函数

public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);
        int numMoved = size - index - 1;
        //数组从index开始往左移动一位
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //最后一个设置为null，便于回收
        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) {
                    //和remove一样，只是少了位置校验
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

get函数

public E get(int index) {
        //判断位置是否合法
        rangeCheck(index);
        //直接返回即可
        return elementData(index);
    }

set函数

public E set(int index, E element) {
        //判断位置是否合法
        rangeCheck(index);

        E oldValue = elementData(index);
        //更新数据
        elementData[index] = element;
        //返回老数据
        return oldValue;
    }

clear函数

public void clear() {
        modCount++;

        // clear to let GC do its work
        //遍历依次置为null
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

小结
发现学了很多都忘记了，还是需要统一整理一下，然后做一下笔记。