ArrayList的特点及源码解读

我们就ArrayList的以下特点来进行源码分析：

1.线程不安全，存放元素是有序的；

2.自动扩容到原来的1.5倍；

3.默认容量为10；

4.数据结构：基于数组实现，类型为Object类型；

5.get方法是通过元素下表进行查询，而不是元素值；

我们将上面的2,3问题放在一起讲解

1.底层数据结构

首先因为ArrayList的底层没有像Vector一样加同步锁，因此它是线程不安全的；

它的底层实现是数组，因此它存放元素是有序的：

//存放我们添加的元素；
transient Object[] elementData; 

2.get方法

在讲这个之前，我们先简单了解一下时间复杂度的概念：

时间复杂度分为O(1),O(n),O(logn)

O(1)

只需要通过查询一次就能找到目标元素；

O(n)

需要从头查询到尾部，例如根据元素值去查询；

O(logn)，

例如二叉树，红黑树这种特殊数据结构的查询方法；

好，在简单了解之后再来思考我们的问题，get方法为什么不根据具体的元素进行查询，而是根据下标进行查询？

通过元素下标直接查询，我们可以精确的定位到元素，因此只需要查询一次，时间复杂度为O(1),效率很高；

而如果根据具体的元素去查询，那么就需要进行循环遍历，直到找到我们指定的目标元素，时间复杂度为O(n)，效率较低；

3.初始化机制及自动扩容机制

ArrayList的初始化机制和自动扩容机制主要体现在add方法上面；

当我们在调用add方法的时候，会传入一个默认的size+1的参数，这个size是数组的长度的，默认值为0，也就是说当我们在第一次调用这个方法的时候，传给下面这个方法的参数值为1；

 ensureCapacityInternal(size + 1);

 这个值又会作为minCapacity参数被带入下面这个方法

 ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));

我们先一步一步看避免混淆

首先当前这个数组elementData，和传入的size+1参数进入到下面这个calculateCapacity方法中

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

在这个方法中，先判断当前数组是否为空，如果为空那么则在默认的容量10和我们传过来的size+1中取最大值并返回，否则就直接返回minCapacity（也就是最开始的size+1）；

  private static final int DEFAULT_CAPACITY = 10;

其实这一步就是做的初始化操作，因为我们第一次调用add方法，传过来的数据size+1的结果=1，因此取最大的肯定也就是默认容量10了；

然后这个返回值就会传入外部的ensureExplicitCapacity方法；

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

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

在这个方法中，判断minCapacity是否大于当前数组的长度，如果大于的话则调用grow方法进行扩容；（假设我们这里还是minCapacity还是第一次到这个地方，那么值依旧1,那么也会进入到grow方法里面）也就是说最核心的操作就是在grow方法中进行的，我们再往下看grow方法：

    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);
    }

在grow方法中我们可以清晰的看到，首先他获取到了当前数组的长度，作为旧容量（oldCapacity），再将旧容量+旧容量往右移动1位（除以二），得到新容量（newCapacity）

这里也就解释了为什么自动扩容是原先的1.5倍了

再往下看，它判断新容量是否小于我们传过来的（size+1），如果小于则将我们传过来的值赋给新容量，这一步的操作是为什么呢？

还是回到我们上面第一次调用这个方法的时候，传过来的size+1是不是1呢，那么旧容量也就是0，新容量=0+0除以2还是等于0，那么这个时候就会走到这个方法，最终将我们的size+1赋值给新容量，也就是说这个判断也是帮助做初始化工作的；

而下面的判断MAX_ARRAY_SIZE值，是Integer包装类的最大值-8

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

而这个MAX_VALUE的值是2的31次方-1，因此正常情况是不会走到这个判断内部的，主要是增强操作；

那么最后的扩容操作就是Arrays类下面的copyof方法了

这个方法就是根据我们传入的数组长度（第二个参数newCapacity），生成一个新的数组，并且将我们传入的数组（第一个参数elementData，也就是我们扩容前的数组/刚刚创建的数组），copy到这个新数组中并返回。

4.remove方法以及缩容机制

remove方法其实就是将目标元素后面的所有元素整体往前移动一位；

remove方法也有两种实现，一种是基于元素内容删除，时间复杂度为O(n),另一种是根据元素的下标进行删除，时间复杂度为O(1);

我们在删除的时候就需要考虑缩容问题；

缩容

我们在进行删除之后，目标元素后面的所有元素整体往前移动了一位，那么最后一个位置的元素就为空；

例如在根据元素值进行删除的remove方法中，它先通过循环遍历，找到了该元素的下标，然后将下标传入了下面这个fastRemove方法中：

private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //将最后一个位置的设置为空
    elementData[--size] = null; // clear to let GC do its work  
}

在这个方法中，首先计算了numMoved（删除的目标元素的后面的元素个数）即需要被移动的元素个数；

然后再调用System里面的arraycopy方法：

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);
//Object src：原数组；

//int srcPos：从原数据的起始位置开始；

//Object dest：目标数组

//int destPos：目标数组的开始起始位置；

//int length：要copy的数组的长度；

该方法的意思就是：从原数组的指定位置开始，截取指定长度copy到从目标数组的指定位置开始；

最后再将最后一个位置设置为空；

5.modCount的作用

我们刚刚在看remove和add方法源码的时候会发现，在核心方法的最开始总是会有一个modcount++，那么这个modcount是什么呢？

我们刚刚在研究add和remove方法的时候，都是在单线程的思维下进行的，如果场景变为多线程场景，就有可能出现下面这个问题：

A线程在遍历集合，而B线程在对这个集合存放数据，那么就有可能导致A线程一直在遍历造成死循环；

因此我们加入这个modCount值进行记录判断;

我们在进行集合的foreach遍历的时候，查看它的源码会发现：

public void forEach(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    final int expectedModCount = modCount;
    @SuppressWarnings("unchecked")
    final E[] elementData = (E[]) this.elementData;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        action.accept(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

它在遍历之前会先拿到我们的modCount值，如果我们在遍历的时候这个modCount值发生了变化，说明有其他线程操作了当前线程的这个集合，那么就会抛出ConcurrentModificationException异常；

modCount这个机制也叫做fastClass机制。