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!
