手写ArrayList集合

前言

最近仔细的研究了下集合框架的源码，并完全手写下来，这里将每一步的进展记录下来，欢迎指点。

构造器:

ArrayList的构造器，分别为无参构造器、传入初始大小的有参构造器、传入一个集合类型的有参构造器，这里只介绍前面两种常用的构造器。

无参构造器:
ArrayList的底层实际就是使用数组来实现的，我们创建一个数组，用于之后对ArrayList的操作。

//ArrayList底层就是用Object数组实现的
 private Object[] elementData;

创建一个空的Object数组，用于无参构造器使用

//声明一个空的数组，用于空构造器的初始化
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

声明无参构造器时，没有指定大小，在add方法时，才进行了初始化容量，这里直接将空数组的地址，赋给之后需要操作数组即可。

//未指定初始容量大小的构造器
 public ExArrayList() {
     this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
 }

带初始化的有参构造器:
这里需要判断传入值的一个正确性，注意这里之所以将initialCapacity等于0的逻辑单独抽出来，而没有new Object的原因是，这样做会导致add方法的判断错误，所以直接等于我们创建的空数组的地址。

//指定初始容量大小的构造器
 public ExArrayList(int initialCapacity) {
     //判断传值的正确性
     if (initialCapacity > 0) {
         this.elementData = new Object[initialCapacity];
     } else if (initialCapacity == 0) {
         //等于0时之所以没有和大于0的逻辑放在一起，是因为直接new Object后
         //会导致之后add方法声明的是初始大小为10的数组
         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
     } else {
         throw new IllegalArgumentException("Illegal Capacity: " +
                 initialCapacity);
     }
 }

添加方法

添加方法作为我们最常用的一个方法，其实内部原理非常简单，但设计的非常巧妙，这里介绍四个添加方法，add(E e)、add(int index,Object element)、addAll(Collection c)、add(int index,Collection c)

add(E e)：
所有的添加方法在添加前，都需要判断当前的一个容量大小是否足够，即数组在声明时，大小都是固定了的，添加一个元素，就需要判断容量是否足够，如果不够就进行一个扩容，然后在添加元素。
传入的参数表示扩容的一个最小大小，即当前使用大小加一。

public boolean add(E e) {
        //1.判断当前集合容量是否足够，参数表示最小容量
        ensureCapacityInternal(size + 1);
        //2.添加对象
        elementData[size++] = e;
        return true;
 }

size是记录当前数组实际使用的大小，即数组里有多少数据，添加一个元素会加一，删除则会减一。

//记录当前数组实际使用大小
 private int size;

这里就可以知道，当时带初始化的有参构造器在判断时，为什么将等于0的逻辑分离出来了，如果当时是直接new Object,下面的if条件就不满足了，最小容量就还是1，影响之后的一个扩容。

    /**
     * @param minCapacity 最小扩容大小(即当前实际使用容量大小+1)
     */
    private void ensureCapacityInternal(int minCapacity) {
        //判断是否还是个空数组
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //默认扩容大小10,选两个值最大的一个数
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

在添加元素的时候，如果elementData还是一个空数组，之后就会将其扩容为大小为10的数组。

//默认的初始容量大小
private static final int DEFAULT_CAPACITY = 10;

这个方法就是在判断是否需要进行扩容，如果你传入的最小扩容量是大于当前数组的长度时，就需要进行扩容。

private void ensureExplicitCapacity(int minCapacity) {
        //修改次数加1
        modCount++;

        //如果当前最小扩容大小大于数组当前长度,则选择扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

modCount 参数是用于记录修改的次数，主要是用于使用迭代器进行循环输出时，如果你在循环中，对ArrayList进行添加或删除的操作时，会导致modCount的循环前和循环后的值不一致，然后抛出一个并发异常的错。

//修改次数，防止并发修改
protected transient int modCount = 0;

扩容的策略默认是为之前大小的1.5倍， Arrays.copyOf是将elementData的大小变为newCapacity，并且保留elementData里的数据。

   //扩容
    private void grow(int minCapacity) {
        //旧数组也即当前数组大小
        int oldCapacity = elementData.length;
        //新数组的大小(size >> n == size / 2的n次方)
        //偶数:旧数组大小的1.5倍
        //奇数:旧数组大小的1.5倍的整数部分(因为int的特性)
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //判断新大小是否大于最小容量大小
        if (newCapacity - minCapacity < 0) {
            //初始容量大小为1的时候会出现该情况
            newCapacity = minCapacity;
        }
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //将数组的大小变为newCapacity,值依旧存在
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

MAX_ARRAY_SIZE 数组允许的最大容量

//数组允许的最大容量(减8的原因是因为数组需要8个bytes去存储自己的大小)
 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

一系列操作完毕后，就将对象添加到数组中去，并且size加一。

add(int index, Object element):
指定下标插入对象

public void add(int index, Object element) {
        //1.判断传入的下标值的准确性
        rangeCheckForAdd(index);
        //2.判断当前集合容量是否足够，参数表示最小容量
        ensureCapacityInternal(size + 1);
        //3.将指定下标后的元素,全部向后复制一遍
        //① 源数组 ② 源数组开始复制的下标 ③ 复制后目标数组
        //④ 目标数组开始复制的下标 ⑤ 源数组需要复制的长度
        System.arraycopy(elementData, index, elementData, index + 1,
                size - index);
        //4.这时可以将指定下标的元素替换为需要插入的值,下标index和下标index+1此时一致
        elementData[index] = element;
        //5.实际使用的数组大小加一
        size++;
    }

大致的思路和直接添加一个对象一样，只不过需要判断下标值的准确性

private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

之后判断是否需要扩容，然后将你指定的下标后的元素,全部向后复制,为之后插入的值腾位置，并且保持其余元素值不变
arraycopye方法:

//① 源数组 ② 源数组开始复制的下标 ③ 复制后目标数组
        //④ 目标数组开始复制的下标 ⑤ 源数组需要复制的长度
System.arraycopy(elementData, index, elementData, index + 1,
                size - index);

之后在将指定下标的元素，替换为需要插入的元素，实际使用的数组大小加一即可。

addAll(Collection c)
将传入的集合里的元素，都添加到elementData数组中，修改实际使用大小，完成添加
首先将该集合转为数组，获取该数组的长度，然后按照惯例判断当前数组的容量是否足够，这里传入的最小容量的参数就不是size+1,而是size+需要插入的元素个数，然后使用arraycopy方法将元素都复制到elementData中去，之后修改实际使用大小。

 public boolean addAll(Collection c) {
        //1.将一个集合转为数组
        Object[] a = c.toArray();
        int numNew = a.length;
        //2.判断当前集合容量是否足够，参数表示最小容量(实际使用大小和新增的数组大小)
        ensureCapacityInternal(size + numNew);
        //3.将传入的集合中所有的元素，复制到elementData中
        System.arraycopy(a, 0, elementData, size, numNew);
        //4.修改实际使用长度
        size = size + numNew;
        return numNew != 0;
 }

addAll(int index, Collection c):
在指定下标中，插入一个集合的元素，其实这个方法等于就是前面两个方法的结合体了
和前一个方法比，多了两步，一个是判断需要插入的集合，是否可以直接在当前数组的尾巴后面插入，如果是直接在尾部添加元素，即直接复制元素即可，如果是在中间插入元素的话，就需要将源数组的中间的元素给向后复制需要添加的元素的个数位，然后在覆盖元素。

public boolean addAll(int index, Collection c) {
        //1.将一个集合转为数组
        Object[] a = c.toArray();
        int numNew = a.length;
        //2.判断当前集合容量是否足够，参数表示最小容量(实际使用大小和新增的数组大小)
        ensureCapacityInternal(size + numNew);
        //3.判断求出需要移动的元素个数,来决定是否需要移动元素
        int numMoved = size - index;
        if (numMoved > 0) {
            //4.将index后的元素向后移numNew,给新添加的元素腾位置
            System.arraycopy(elementData, index, elementData, index + numNew,
                    numMoved);
        }
        //5.将传入的集合中所有的元素，复制到elementData中
        System.arraycopy(a, 0, elementData, index, numNew);
        //6.修改实际使用长度
        size = size + numNew;
        return numNew != 0;
    }

删除和获值

删除方法的话，在源码中也是有两种形式，一个是根据下标删除，一个是根据对象删除，后面的方面过于呆板，不进行解释了。

elementData(int index):
获取值，即根据对应的下标返回对应的元素

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

remove(int index):
我们可以发现，在对数组的操作时，尤其是增删对中间元素操作时，都是需要移动元素，来腾出位置或直接覆盖某个元素，来达到目标的，这也就是为什么数组比链表的增删操作慢的一个原因，并且数组在声明时就需要申请一段连续的空间内存来存值，申请的空间过大之后又可能会造成浪费，而过小的话动不动就需要扩容。

public E remove(int index) {
        //1.检查传入的下标准确性
        rangeCheckForAdd(index);
        //2.修改次数加1
        modCount++;
        //3.获得旧值
        E oldValue = elementData(index);
        //4.得到需要移动的元素(不包括自己),来判断是否需要复制
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            //需要复制对应下标后的所有元素,向前复制(覆盖需要删除的元素)
            // 此时size-1的元素等于size-2
            System.arraycopy(elementData, index + 1, elementData, index, numMoved);
        }
        //5.将最后一个元素置为null
        elementData[--size] = null;
        return oldValue;
    }

之后会介绍LinkedList的源码，可以发现两者的优缺点。