JDK 版本：1.8.0_101

对于Java集合家族的 ArrayList ，想必你听到最多的都基本和下面这句话有关：

ArrayList支持快速的随机访问，但是在插入和删除时通常来讲速度是比较慢的。

What did u say？[?手动黑人问号脸?]
作为一个菜鸡，我也不明所以，最近抽时间也好好学习了一下，说实话，部分方法还是比较简单的，稍微有点基础的都能看懂，有一些确实不好理解，也看了很多大佬的博客，总的来说也算是看懂了，知其所以然了就ok！那接下来就带着上面的问题来一步一步的学习吧！

ArrayList 是存储单个元素的 顺序表 结构，顺序表 结构是数据结构中 线性结构 的一种，同类别的还有 链表、 栈 以及 队列。ArrayList 底层是基于 数组 的，数组就是一种 顺序表，可以通过下标进行快速定位并获取指定位置的元素。

构造器

首先出场的当然就是ArrayList的常用构造器了(注释也比较清晰)

// 1. 无参构造器
new ArrayList<>();
// 以下是该构造器的源码
// ArrayList 内部维护的一个存储元素的 Object 数组
transient Object[] elementData;
// 默认容量 Object 类型空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
  // 初始化为一个空数组
  this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// 2. 有参构造器
new ArrayList<>(20);
// 以下是该构造器的源码，传递一个int类型的参数作为ArrayList的初始容量
// Object 类型空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
public ArrayList(int initialCapacity) {
    // (1). 如果参数大于0，创建一个初始长度为参数值的 Object 类型数组并赋值给 elementData
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    // (2). 如果参数等于0，直接将空数组 EMPTY_ELEMENTDATA 赋值给 elementData
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    // (3). 其他情况也就是小于0时，抛出 非法参数异常
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

一般建议是：集合初始化的时候指定初始值大小，倘若暂时无法确定集合大小，那就指定该集合的默认值，ArrayList 默认大小为10

添加

对于添加功能来说，最常用的两个方法分别是 add(E e) 和 add(int index, E element)
(1). add(E element)：直接添加元素是在数组末尾添加，不会有数组元素需要移动的情况

public boolean add(E e) {
    // 该方法主要做了两件事，第一就是 modCount++，第二就是判断是否需要扩容，请参照后文“遗留问题”
    ensureCapacityInternal(size + 1); 
    // 将元素添加到数组末尾，size+1
    elementData[size++] = e;
    return true;
}

(2). add(int index, E element)：在数组的指定位置添加元素，该方法就有可能出现插入比较慢的情况，因为可能需要移动数组中的部分元素

public void add(int index, E element) {
    // 该方法主要是检查 index 是否合法，即是否在区间 (0,size)
    rangeCheckForAdd(index);
    // 该方法主要做了两件事，第一就是 modCount++，第二就是判断是否需要扩容，后面再细说
    ensureCapacityInternal(size + 1); 
    // 主要意图是将原数组 elementData index位置之后的元素都往后移动一位
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 将待添加元素添加到移动后的数组的 index 位置
    elementData[index] = element;
    // 数组长度+1
    size++;
}

通过以上对添加方法的分析，请慎重选择！！！当然数据量不大的情况下也没有什么影响，这个可以自己写代码测试一下！

删除

对于删除功能来说，最常用的两个方法分别是 remove(Object o) 和 remove(int index)
(1). remove(Object o)：

public boolean remove(Object o) {
    // 1. 判断待删除元素是否为空，因为 ArrayList 允许存储 null
    if (o == null) {
        // 循环遍历
        for (int index = 0; index < size; index++)
            // 找到了 null 元素的 index
            if (elementData[index] == null) {
                // 该方法做了三件事，第一 modCount++，第二将 null 元素所在位置之后的所有元素向前移动一位
                // 第三将 --size 位置(即元数组最后一位)的数组元素置为 null，让 GC 去回收
                fastRemove(index);
                return true;
            }
    // 若不为空
    } else {
        // 循环遍历
        for (int index = 0; index < size; index++)
            // o.equals() 调用的是 Object 的方法，判断的是调用对象和比较对象是否 == ，若 == ，直接删除
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

// 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
}

(2). remove(int index)：删除指定 index 处的元素

public E remove(int index) {
    // 边界检查
    rangeCheck(index);
    // modCount 自增
    modCount++;
    // 获取待删除 index 处的元素
    E oldValue = elementData(index);
    
    int numMoved = size - index - 1;
    // 判断是否需要移动元素，> 0 说明需要移动元素，否则说明要删除的元素就是最后一个
    if (numMoved > 0)
        // 移动元素
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 将最后索引处的元素置为 null，等待 GC 回收
    elementData[--size] = null; 
    // 返回要删除的元素
    return oldValue;
}

好了，看了删除的两个方法，发现都 可能会有 数组拷贝的情况，也就是需要移动部分元素的情况，所以当数据量比较庞大时，性能问题可能不是很好

修改

修改 ArrayList 中的元素使用的方法是 set(int index, E element)

public E set(int index, E element) {
    // 边界检查
    rangeCheck(index);
    // 获取指定 index 处的元素
    E oldValue = elementData(index);
    // 直接将新元素放到 elementData数组 index 位置处
    elementData[index] = element;
    // 返回原来该位置的元素
    return oldValue;
}

这个方法就比较简单了，不多解释了！

查询

get(int index) 方法

public E get(int index) {
    // 边界检查
    rangeCheck(index);
    // 直接返回指定 index 处的元素
    // (PS：当你知道了 LinkedList 获取指定位置元素的方式后你就明白 ArrayList 它为什么快了)
    return elementData(index);
}

ArrayList 支持快速随机访问不只是因为数组，还有一个原因就是它实现了 RadomAccess 接口，实现了该接口，fori遍历 会比 迭代器遍历 快，也就是

for (int i=0, n=list.size(); i < n; i++) {
    list.get(i);
}
比
for (Iterator i=list.iterator(); i.hasNext(); )
    i.next();
}
要快

关于迭代器遍历，大佬的这篇文章 ArrayList 源码分析|田小波的技术博客 讲解的很详细
所以当你想在集合遍历里做删除操作时，要格外注意！！！

遗留问题：ensureCapacityInternal(size + 1)

private void ensureCapacityInternal(int minCapacity) {
    // 下面的判断主要目的是检查使用的构造函数是不是没有参数的，查看无参构造函数便可明白
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 取两者中的最大值
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 是否需要扩容方法
    ensureExplicitCapacity(minCapacity);
}

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

    // 判断是否需要扩容，调用扩容具体实现方法
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

// 扩容具体实现
private void grow(int minCapacity) {
    // 获取数组长度定义为 旧容量
    int oldCapacity = elementData.length;
    // 旧容量 + 旧容量无符号右移一位 定义为 新容量
    // 假设数组长度为5，5的二进制表示为 0000 0000 0000 0101
    // 右移一位：0000 0000 0000 0010，对应的十进制数是2，那么 newCapacity = 5 + 2 
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8，不要去纠结为什么要 减8
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        // hugeCapacity(minCapacity) 方法的意图就是给 newCapacity 取一个最大值，比较简单
        newCapacity = hugeCapacity(minCapacity);
    // 将 elementData 数组拷贝一份并设定数组长度为 newCapacity，重新赋值给 elementData
    elementData = Arrays.copyOf(elementData, newCapacity);
}

经过上面的分析，是不是对常用方法也有了一点自己的理解了呢？学无止境，要掌握的知识还有很多，你在什么阶段拼搏了呢？加油吧，生活还是很美好的，不要放弃！
最后，送给自己一句话：千万不要假装自己很努力！！！

我是bearPotMan，一个经验不足的十八线演(码)员(农)。
Know everything,control everything!