Java 集合-ArrayList

目录

1.类声明

2.属性

3.构造器

4.添加元素和扩容

5.在指定索引位置添加元素

6.删除指定位置元素

---

​​​​​​​

1.类声明

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

实现了4个接口：

• java.util.List 接口，提供数组的添加、删除、修改、迭代遍历等操作。
• java.util.RandomAccess 接口，表示 ArrayList 支持快速的随机访问。
• java.io.Serializable 接口，表示 ArrayList 支持序列化的功能。
• java.lang.Cloneable 接口，表示 ArrayList 支持克隆。

继承了 java.util.AbstractList 抽象类，ArrayList 大量重写了 AbstractList 提供的方法实现

2.属性

    // 版本号
    private static final long serialVersionUID = 8683452581122892189L;

    // 默认容量
    private static final int DEFAULT_CAPACITY = 10;

    // 空对象数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

    // 默认空对象数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 元素数组
    transient Object[] elementData; //不使用 private 修复，方便内嵌类的访问

    // 元素数组中真实元素的个数
    private int size;

3.构造器

一共3种

// 无参数构造方法
    public ArrayList() {
        // 初始化是一个空数组，只有在首次添加元素时，才会真正初始化为容量是10的数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    // 构造方法，根据传入的初始化容量，创建 ArrayList 数组
    public ArrayList(int initialCapacity) {
        // 初始化容量大于 0 时，创建 Object 数组
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
            // 初始化容量等于 0 时，使用 EMPTY_ELEMENTDATA 对象
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            // 初始化容量小于 0 时，抛出 IllegalArgumentException 异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                    initialCapacity);
        }
    }

    // 构造方法，使用传入的 c 集合，作为 ArrayList 的 elementData
    public ArrayList(Collection<? extends E> c) {
        // 将 c 转化为 object 数组
        elementData = c.toArray();
        // 如果数组大小不等0
        if ((size = elementData.length) != 0) {
            // 如果集合元素不是 Object[] 类型
            if (elementData.getClass() != Object[].class)
                //
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 等于0，使用 EMPTY_ELEMENTDATA
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

4.添加元素和扩容

    // 添加元素
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);
        elementData[size++] = e;
        return true;
    }

    // 确保内部容量
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    // 计算容量
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        // 如果是空对象，就返回10和minCapacity之间较大的值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    // 确保许可容量
    private void ensureExplicitCapacity(int minCapacity) {
        // ArrayList 的父类AbstractList的一个成员变量，作用是记录ArrayList的size变化，添加元素时，该变量会自增一次。
        modCount++;
        // 如果数组中真实存储的元素个数等于数组容量
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    // 进行扩容操作
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        // 定义新数组的容量，新数组的容量大小为旧数组容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 扩容1.5倍后，如果仍不够，新数组容量以 minCapacity 为准，首次添加时扩容到10
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 如果新数组的容量大小超过了定义的MAX_ARRAY_SIZE大小
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 将旧数组复制到新数组中
        elementData = Arrays.copyOf(elementData, newCapacity);
    }


    // 最大容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    // 大容量
    private static int hugeCapacity(int minCapacity) {
        // 传入的参数必须大于0，否者报错
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                // 整型的最大值 2^{31}-1
                Integer.MAX_VALUE :
                // 容量限定值2^{31}-1-8
                MAX_ARRAY_SIZE;
    }

5.在指定索引位置添加元素

    // 在指定索引位置添加元素
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);
        // 将 index + 1 位置开始的元素，进行往后挪
        System.arraycopy(elementData, index, elementData, index + 1,
                size - index);
        // 设置到指定位置
        elementData[index] = element;
        // 数组大小加一
        size++;
    }

    // 校验位置是否在数组范围内
    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();
    }

6.删除指定位置元素

    // 移除指定位置元素
    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            // 将 index + 1 位置开始的元素，进行往前挪
            System.arraycopy(elementData, index+1, elementData, index,
                    numMoved);
        elementData[--size] = null;

        return oldValue;
    }

总结：ArrayList底层时数组实现的，数组有索引，所以查询特别快，向指定位置增删元素慢，因为需要将插入位置的数组整体向后或向前移动。初始化是一个空数组，首次添加元素的时候，初始化为容量是10的数组。扩容是扩容到原容量的1.5倍，然后新建一个数组，将旧数组复制到新数组中。