数据结构与算法-ArrayList-add(E e)方法源码分析

查看ArrayList的初始化

  在创建ArrayList 集合的时候，如果不指定集合的长度，就走空参构造方法，在构造方法内部为 elementData属性赋初始值（DEFAULTCAPACITY_EMPTY_ELEMENTDATA）

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

  可以看到DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的初始值是个空的数组。

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

---

ArrayList集合中的add（E e）方法分析

  来到ArrayList类，找到add 方法；可以很清楚的看到该方法主要有三行代码：
  一： 扩容操作；ensureCapacityInternal(size + 1);
  二：执行 添加元素操作。elementData[size++] = e;
  三：没有发生异常的话返回 true，说明添加成功

属性说明：

1. elementData 用于存储数据的数组（也就说明了ArrayList底层使用数组实现的）
2. size 表示集合中数据的的大小、数量

transient Object[] elementData;
private int size;

进入到ensureCapacityInternal方法查看

1. 首先判断该数组是否为空；
2. 初始化ArrayList集合的时候 elementData 数组是没有数据的，所以会走到if 语句里面；
3. minCapacity 是传进来的形参，表示当前集合的容量大小；
4. DEFAULT_CAPACITY 是ArrayList 提供的常量，默认容量 大小为10；
5. 调用 Math.max 类的max 方法比较DEFAULT_CAPACITY 和minCapacity ，谁大就给 minCapacity 重新赋值；

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

Math的max方法代码

    public static int max(int a, int b) {
        return (a >= b) ? a : b;
    }

---

执行完if 语句里面的代码后，调用ensureExplicitCapacity(int minCapacity)方法

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

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

1. modCount 属性是ArrayList集合的抽象父类（AbstractList）提供的
2. 想知道modCount 属性 是干嘛的可以访问以下这篇文章；

https://blog.csdn.net/u012926924/article/details/50452411

3. modCount 自增之后 ， if 语句判断 如果集合内元素的个数 减去 数组的长度 还大于 0 就调用 grow(minCapacity) 方法 执行扩容。

进入到grow(minCapacity) 方法查看

1. min capacity 这次扩容最小需要的容量
2. oldCapacity 扩容前原始数组容量
3. newCapacity是预计要扩容到的容量

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        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:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

进入到copyOf方法查看

    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

再进入到重载的copyOf方法查看

    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

进入到hugeCapacity(int minCapacity)方法查看

• 如果预计要扩容到的容量 减去 最大容量 大于0 则调用hugeCapacity 方法

private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

---

完整代码

package cn.bloghut.linear;

import java.util.Arrays;

/**
 * @author by 闲言
 * @classname MyArrayList
 * @description ArrayList-add(E e)方法源码
 * @date 2021/7/14 11:07
 */
public class MyArrayList<E> {
    /**
     * 存储数据数组
     */
    transient Object[] elementData;
    /**
     * 集合数据长度
     */
    private int size;
    /**
     * 默认数据
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    /**
     * 默认长度
     */
    private static final int DEFAULT_CAPACITY = 10;
    /**
     * 最大容量--为了避免一些机器内存溢出，最大长度依然是Integer.MAX_VALUE，并不是Integer.MAX_VALUE-8
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * 空参构造
     */
    public MyArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 添加数据
     *
     * @param e
     * @return
     */
    public boolean add(E e) {
        //在添加数据的时候调用 是否需要扩容
        ensureCapacityInternal(size + 1);
        //执行添加操作 size自增1（指针向后移动）
        elementData[size++] = e;
        return true;
    }

    /**
     * 根据参数minCapacity，重置 elementData
     *
     * @param minCapacity
     */
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

    /**
     * 根据参数minCapacity，重置 elementData
     *
     * @param minCapacity
     */
    private void ensureExplicitCapacity(int minCapacity) {
        //minCapacity 减去 数组长度 大于0说明已经超出了数组的 存储空间，需要扩容了
        if (minCapacity - elementData.length > 0) {
            grow(minCapacity);
        }
    }

    /**
     * 动态扩容
     *
     * @param minCapacity
     */
    private void grow(int minCapacity) {
        //min capacity 这次扩容最小需要的容量
        //oldCapacity 扩容前原始数组容量
        int oldCapacity = elementData.length;
        //newCapacity是预计要扩容到的容量
        //oldCapacity >> 1  原数组右移 1位得到新值
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //复制数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

    @Override
    public String toString() {
        return "MyArrayList{" +
                "elementData=" + Arrays.toString(elementData) +
                ", size=" + size +
                '}';
    }
}