ArrayList源码分析

最新推荐文章于 2025-05-22 17:44:26 发布

有梦想的打工仔

最新推荐文章于 2025-05-22 17:44:26 发布

阅读量125

点赞数

分类专栏： java源码分析专栏文章标签： java 数据结构

本文链接：https://blog.youkuaiyun.com/qq47653423/article/details/115283193

版权

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

11 篇文章

订阅专栏

本文详细介绍了ArrayList的内部实现，包括其继承结构、成员变量、构造函数、核心方法如add、get、set及remove。ArrayList基于数组实现，扩容策略为1.5倍增长。在插入和删除操作时，相比于LinkedList效率较低。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一：ArrayList的继承体系
在这里插入图片描述
ArrayList继承自AbstractList并实现了List，RandomAccess, Cloneable, Serializable等接口

注：1.RandomAccess是一个标记接口，用来表明其支持快速（通常是固定时间）随机访问
2.Cloneable接口也是一个标记接口，用来表示其支持clone
3.Serializable接口，标记接口，表示支持序列化

二：ArrayList的成员变量分析

    // 默认初始化大小
    private static final int DEFAULT_CAPACITY = 10;


    // 当size为0时返回的数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

     // 调用无参构造时返回的数组
     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

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

    //当前容器中元素的个数
    private int size;
    
    //最大容量大小 超过这个值可能会抛出OutOfMemoryError
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

三：ArrayList的构造函数

1.无参构造函数

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

2.指定初始化大小的构造函数

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            // 创建一个指定大小的数组赋值给elementData 
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
           // 如果传的是0 直接把空数组复制给elementData 
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

3.传入一个collection的构造函数

    public ArrayList(Collection<? extends E> c) {
        // 将collection转化为数组
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // 如果c.toArray()返回的不是object[],则转化一下
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 大小为0 时 将空数组赋值给elementData 
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

四：ArrayList的add(E e)方法与add(int index, E element)

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    public void add(int index, E element) {
        //检查索引是否越界
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        //size自增
        size++;
    }

两个方法主要的逻辑都是在ensureCapacityInternal(size + 1)方法中

private void ensureCapacityInternal(int minCapacity) {
         // 如果ArrayList还没有初始化大小
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            // 比较传入的minCapacity和默认初始化大小
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

private void ensureExplicitCapacity(int minCapacity) {
        //   modCount用于记录ArrayList修改的次数 主要用于fast-fail机制
        modCount++;

        // 如果minCapacity大于elementData的大小，那么代表需要扩容了
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

扩容：

private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //每次扩容为上一次的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
           //如果1.5倍依然小于minCapacity的话，那么指定大小为minCapacity
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            //若 newCapacity 大于最大存储容量，则进行大容量分配
            newCapacity = hugeCapacity(minCapacity);
        // 调用Arrays.copyOf()方法将元素复制到扩容之后的新数组中，底层调用的System.arraycopy（）方法
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

   //进行大容量分配
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

/*
将指定源数组的数组，从指定位置，复制到指定数组的指定位置，要赋值的数组元素数量等于length。
- src：源数组
- srcPos：源数组中的起始位置
- dest：目标数组
- destPos：目标数组的起始位置
- length：要赋值的数组元素数量
*/
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

五：ArrayList的get(int index)方法与set(int index, E element)

1.get(int index)方法:

    public E get(int index) {
        // 检查索引是否越界
        rangeCheck(index);
        //通过索引从elementData数组中将元素取出返回
        return elementData(index);
    }

    E elementData(int index) {
        return (E) elementData[index];
    }

2.set(int index, E element)方法：

    public E set(int index, E element) {
        // 检查索引是否越界
        rangeCheck(index);
        //将旧值覆盖并返回旧值
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

六：ArrayList的remove(int index)与remove(Object o)方法

1.remove(int index)方法：

public E remove(int index) {
         //检测索引是否越界
        rangeCheck(index);
        // 修改次数 + 1
        modCount++;
        //取出索引所在位置的值
        E oldValue = elementData(index);
        //计算复制数组需要移动的长度
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
         // size自减 并且将数组最后一个元素置为null
        elementData[--size] = null; // clear to let GC do its work
        //返回删除的值
        return oldValue;
    }

2.remove(Object o)方法：

public boolean remove(Object o) {
       //循环数组 找到想要删除的元素进行删除
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    private void fastRemove(int index) {
        //修改次数+1
        modCount++;
        // 计算复制数组需要移动的长度
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //size自减 并且将数组最后一个元素置为null
        elementData[--size] = null; // clear to let GC do its work
    }

七：总结

ArrayList底层是基于数组进行实现的，而它的扩容机制也是通过将原数组元素复制到另一个1.5倍容量大小的新数组中来完成的，所以在进行插入删除数据的时候可能效率就没有LinkedList好了.