1.ArrayList介绍
ArrayList是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List，RandomAccess，Cloneable，java.io.Serializable这些接口。
2.ArrayList的线程安全性
对ArrayList进行添加元素的操作的时候是分两个步骤进行的:
- .即第一步先在object[size]的位置上存放需要添加的元素；
- .第二步将size的值增加1。
由于这个过程在多线程的环境下是不能保证具有原子性的，因此ArrayList在多线程的环境下是线程不安全的。
具体举例说明：在单线程运行的情况下，如果Size = 0，添加一个元素后，此元素在位置 0，而且Size=1；而如果是在多线程情况下，比如有两个线程，线程 A 先将元素存放在位置0。但是此时 CPU 调度线程A暂停，线程 B 得到运行的机会。线程B也向此ArrayList 添加元素，因为此时 Size 仍然等于 0 （注意哦，我们假设的是添加一个元素是要两个步骤哦，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增 加 Size 的值。那好，现在我们来看看 ArrayList 的情况，元素实际上只有一个，存放在位置 0，而Size却等于 2。这就是“线程不安全”了。
3.ArrayList的继承关系
4.ArrayList的数据结构
ArrayList的底层数据结构就是一个数组，数组元素的类型为Object类型，对ArrayList的所有操作底层都是基于数组的。
5.ArrayList的API
// Collection中定义的API
boolean add(E object)
boolean addAll(Collection<? extends E> collection)
void clear()
boolean contains(Object object)
boolean containsAll(Collection<?> collection)
boolean equals(Object object)
int hashCode()
boolean isEmpty()
Iterator<E> iterator()
boolean remove(Object object)
boolean removeAll(Collection<?> collection)
boolean retainAll(Collection<?> collection)
int size()
<T> T[] toArray(T[] array)
Object[] toArray()
// AbstractCollection中定义的API
void add(int location, E object)
boolean addAll(int location, Collection<? extends E> collection)
E get(int location)
int indexOf(Object object)
int lastIndexOf(Object object)
ListIterator<E> listIterator(int location)
ListIterator<E> listIterator()
E remove(int location)
E set(int location, E object)
List<E> subList(int start, int end)
// ArrayList新增的API
Object clone()
void ensureCapacity(int minimumCapacity)
void trimToSize()
void removeRange(int fromIndex, int toIndex)6.ArrayList源码分析
属性
ArrayList的主要属性如下代码所示:
//序列化id
private static final long serialVersionUID = 8683452581122892189L;
//容器默认初始化大小
private static final int DEFAULT_CAPACITY = 10;
//一个空对象
private static final Object[] EMPTY_ELEMENTDATA = {};
//一个空对象，如果使用默认构造函数创建ArrayList，则默认对象内容是该值
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//ArrayList存放对象的容器，后面的添加、删除等操作都是基于该属性来进行操作
transient Object[] elementData;
//当前列表已使用的长度
private int size;
//数组最大长度（2147483639），这里为什么是Integer.MAX_VALUE - 8是因为有些虚拟机在数组中保留了一些头部信息，防止内存溢出
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//这个是从AbstractList继承过来的，代表ArrayList集合修改的次数
protected transient int modCount = 0;关于Java中transient关键字的解释：
我们都知道一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。
然而在实际开发过程中，我们常常会遇到这样的问题，这个类的有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。
总之，java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。
ArrayList 是大家最为常用的集合类，我们先来看下常用的方法：
List<String> dataList = new ArrayList<>();//创建 ArrayList
dataList.add("test");//添加数据
dataList.add(1,"test1");//指定位置，添加数据
dataList.get(0);//获取指定位置的数据
dataList.remove(0);//移除指定位置的数据
dataList.clear();//清空数据构造函数
1).无参构造函数
如果不传入参数，则使用默认无参构造方法创建ArrayLisy对象，如下：
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}注意：此时我们创建的ArrayList对象中的elementData中的长度是0，size是0，当进行第一次add的时候，elementDate将会变成默认的长度：10。
2).带int类型的构造函数
如果传入参数，则代表指定ArrayList的初始数组长度；传入参数如果是大于0，则使用用户的参数初始化；如果参数等于0，则用内部的空对象EMPTY_ELEMENTDATA的地址直接赋值给elementData；否则抛出异常，如下：
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}上面的代码比较简单，两个构造方法做的事情并不复杂，目的都是初始化底层数组 elementData。区别在于无参构造方法会将 elementData 初始化一个空数组，插入元素时，扩容将会按默认值重新初始化数组。而有参的构造方法则会将 elementData 初始化为参数值大小（>= 0）的数组。
3).带Collection对象的构造函数
· 将Collection对象转换成数组，然后将数组的地址赋值给elementData。
· 更新size的值，如果size的值等于0直接将内部空对象EMPTY_ELEMENTDATA的地址赋值给elementData。
· 如果size的值大于0，则执行Arrays.copy方法，把Collection对象的内容copy(可以理解为深拷贝)到elementData中，并且这些元素是按照该collection的迭代器返回它们的顺序排列的。
public ArrayList(Collection<? extends E> c) { // 集合参数构造函数
elementData = c.toArray(); // 转化为数组
if ((size = elementData.length) != 0) { // 参数为非空集合
if (elementData.getClass() != Object[].class) // 是否成功转化为Object类型数组
elementData = Arrays.copyOf(elementData, size, Object[].class); // 不为Object数组的话就进行复制
} else { // 集合大小为空，则设置元素数组为空
this.elementData = EMPTY_ELEMENTDATA;
}这里介绍下System.arraycopy和Arrays.copy方法，因为后分析源码时会经常用到。
System.arraycopy方法：它就是从指定的源数组将元素中复制到目标数组，复制从指定的位置开始，到设定的复制长度结束，然后从目标数组的指定起始位置依次插入。
// src 源数组
// srcPos 源数组要复制的起始位置
// dest 要赋值到的目标数组
// destPos 目标数组放置的起始位置
// length 复制的长度
// 使用了native关键字，说明调用的是其他语言写的底层函数
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);Arrays.copy方法：它新建了一个数组并且将原数组的内容拷贝到长度为newLength的新数组中，并且返回该新数组。
// original 要复制的数组
// newLength 要返回副本的长度
// newwType 要返回的副本类型
// 内部调用了System.arraycopy方法
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;
}区别：
1).System.arraycopy需要目标数组，将原数组拷贝到你自己定义的数值里，而且可以选择拷贝的起点和长度以及放入新数组中的位置。
2).Arrays.copyof是系统自动在内部新建一个数组，调用System.arraycopy将原数组的内容拷贝到长度为newLength的新数组中，并返回新建的数组。
添加元素(ArrayList的add()方法)
//官方解释：将指定的元素追加到列表（elementData）的末尾
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}接下来我们看ensureCapacityInternal方法，以及它内部调用的方法。
//参数值实际是size+1
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//这个方式是判断当前数组是否是个空数组，如果是就返回默认长度10，否则就返回size+1;也就是说如果你是用无参构造函数初始化ArrayList，那么在第一次调用add方法时，默认长度会变成10
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//这个方法首先将集合修改次数加1，然后判断数组的长度是否可以存入下一个元素，如果长度不够会调用grow方法进行扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//这个方法首先定义数组新的长度为原来数组长度的1.5倍，如果新长度减去所需数组的最小长度小于0，那么新长度就等于所需数组最小长度；再下面的判断是如果新长度大于MAX_ARRAY_SIZE(ArrayList内部定义MAX_ARRAY_SIZE的值是：2147483639)就调用hugeCapacity方法，最后调用Arrays.copyOf将扩容后的新数组地址赋值给elementData
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);
}
//如果扩容长度超过MAX_ARRAY_SIZE，则设置长度为Integer.MAX_VALUE，但不是能百分百成功的，这取决于虚拟机。（如果我们可以在某些虚拟机上可以避免OutOfMemory，我们将另外分配Integer.MAX_VALUE，如果你很幸运（取决于虚拟机），我们将成功）
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}最后总结一下add方法的逻辑：
1).确保数组已使用长度（size）加1后可以存入下一个元素。
2).修改次数modCount标识自增1，如果当前数组已使用长度+1后大于当前数组长度，则调用grow方法，扩容数组，grow方法会将当前数组的长度变为原来容量的1.5倍。
3).确保新加的元素有地方存储后，则将新元素添加到位于size++的位置上。
4).返回添加成功的布尔值。
对于在元素序列尾部插入，这种情况比较简单，只需两个步骤即可：
1).检测数组是否有足够的空间插入；
2).将新元素插入至序列尾部。
如下图：
该方法可以按照元素的位置，指定新元素位置插入。
public void add(int index, E element) {
//判断索引位置是否正确
rangeCheckForAdd(index);
//扩容检测
ensureCapacityInternal(size + 1); // Increments modCount!!
//对源数组进行复制处理（位移），从index + 1到size - index
//即向后移动位于当前位置和后面的元素
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//在指定的位置赋值
elementData[index] = element;
size++;
} 该方法首先调用rangeCheckForAdd方法判断指定的位置小于当前数组的长度并且大于0，否则抛出异常。
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}第二步调用的ensureCapacityInternal方法和上面的add方法逻辑一样。
第三步调用System.arraycopy方法把指定下标以及后面的元素全部往后移一位。
最后将新的元素放到指定位置（index）上，并将size+1。
如果是在元素序列指定位置（假设该位置合理）插入，则情况稍微复杂一点，需要三个步骤：
1).检测数组是否有足够的空间；
2).将 index 及其之后的所有元素向后移一位；
3).将新元素插入至 index 处。
如下图：
从上图可以看出，将新元素插入至序列指定位置，需要先将该位置及其之后的元素都向后移动一位，为新元素腾出位置。这个操作的时间复杂度为O(N)，频繁移动元素可能会导致效率问题，特别是集合中元素数量较多时。在日常开发中，若非所需，我们应当尽量避免在大集合中调用第二个插入方法。
//按照指定的Collection迭代器所返回的顺序，依次插入到列表尾部。
public boolean addAll(Collection<? extends E> c) {
// 将c转换为数组
Object[] a = c.toArray();
int numNew = a.length;
//扩容处理，大小为size + numNew
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}该方法首先传过来的Collection集合转换为数组，然后做扩容处理，接着使用System.arraycopy把转换后的数组复制到列表尾部。
修改某个下标的元素:set(int index, E element)方法的作用是指定下标索引处的元素的值。在ArrayList的源码实现中，方法内首先判断传递的元素数组下标参数是否合法，然后将原来的值取出，设置为新的值，将旧值作为返回值返回。
public E set(int index, E element) {
//判断插入位置是否正确，如果大于列表长度会抛出异常
rangeCheck(index);
//获取插入位置的当前元素
E oldValue = elementData(index);
//将新的元素替换当前插入位置的元素
elementData[index] = element;
//返回插入位置老的值
return oldValue;
}删除元素
移除指定位置上的元素
remove(int index)方法的作用是删除指定下标的元素。在该方法的源码中，将指定下标后面一位到数组末尾的全部元素向前移动一个单位，并且把数组最后一个元素设置为null，这样方便之后将整个数组不再使用时，会被GC，可以作为小技巧。而需要移动的元素个数为：size-index-1。
public E remove(int index) {
//判断删除位置是否正确，如果大于列表长度会抛出异常
rangeCheck(index);
//将集合修改次数加1
modCount++;
//获取当前删除位置上的元素
E oldValue = elementData(index);
//判断是否删除的是最后一个元素，如果不是将删除位置后的元素向左移numMoved个位置
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//将列表最后的元素置为null，等待垃圾收集器收集
elementData[--size] = null; // clear to let GC do its work
//返回删除位置老的值
return oldValue;
}移除指定元素
public boolean remove(Object o) {
//因为ArrayList允许存在null，所以需要进行null判断
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
//移除这个位置的元素
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
private void fastRemove(int index) {
//将集合修改次数加1
modCount++;
//判断是否删除的是最后一个元素，如果不是将删除位置后的元素向左移numMoved个位置
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//将列表最后的元素置为null，等待垃圾收集器收集
elementData[--size] = null; // clear to let GC do its work
}移除所有元素
public boolean removeAll(Collection<?> c) {
//进行判断，如果c为null抛出异常
Objects.requireNonNull(c);
return batchRemove(c, false);
}
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
//遍历数组，并检查这个集合是否包含对应的值，移动要保留的值到数组前面，w最后值为要保留的元素的数量
//若保留，就将相同的元素移动到前段；不删除，就将不同元素移动到前段
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// 确保异常抛出前的部分可以完成期望的操作，而被遍历的部分会被接到后面
//r不等于size表示可能出错了
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
//如果w等于size，表示全部元素都保留了，所以也就没有删除操作发生，所以会返回false；反之，返回true，并更改数组
//而w不等于size的时候，即使try块抛出异常，也能正确处理异常抛出前的操作，因为w始终为要保留的前段部分的长度，数组也不会因此乱序
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}上面的删除方法并不复杂，这里以第一个删除方法为例，删除一个元素步骤如下：
1).获取指定位置 index 处的元素值；
2).将 index + 1 及之后的元素向前移动一位；
3).将最后一个元素置空，并将 size 值减 1；
4).返回被删除值，完成删除操作。
如下图：
上面就是删除指定位置元素的分析，并不是很复杂。
现在，考虑这样一种情况。我们往 ArrayList 插入大量元素后，又删除很多元素，此时底层数组会空闲处大量的空间。因为 ArrayList 没有自动缩容机制，导致底层数组大量的空闲空间不能被释放，造成浪费。对于这种情况，ArrayList 也提供了相应的处理方法，最小化ArrayList的实际存储量，ArrayList提供了trimToSize()方法用于将底层数组的容量调整为当前列表保存的实际元素的大小。
如下：
/** 将数组容量缩小至元素数量 */
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}通过上面的方法，我们可以手动触发 ArrayList 的缩容机制。这样就可以释放多余的空间，提高空间利用率。
清空ArrayList内的所有元素，不减小数组容量
public void clear() {
//将集合修改次数加1
modCount++;
//循环将列表中的所有元素置为null，等待垃圾收集器收集
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
//将列表长度设为0
size = 0;
}clear 的逻辑很简单，就是遍历一下将所有的元素设置为空。
查找元素
ArrayList提供了get(int index)用读取ArrayList中的元素。由于ArrayList是动态数组，所以我们完全可以根据下标来获取ArrayList中的元素，而且速度还比较快。
public E get(int index) {
//判断删除位置是否正确，如果大于列表长度会抛出异常
rangeCheck(index);
//直接返回列表中下标等于index的元素
return elementData(index);
}判断元素是否存在列表中
ArrayList提供了contains(Object o)用于判断元素是否存在于列表中。
注意：contains方法会遍历ArrayList。
public boolean contains(Object o) {
//调用indexOf方法判断需要查找的元素在列表中的下标是否大于等于0，小于0则不存在
return indexOf(o) >= 0;
}
public int indexOf(Object o) {
//因为ArrayList允许存在null，所以需要进行null判断
if (o == null) {
//遍历列表，如果列表存在null值的元素，直接返回其下标位置
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
//遍历列表，使用equals判断是否有相等的元素，有的话直接返回其下标位置
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
//列表中不能存在传进来的元素，返回-1
return -1;
}截取ArrayList部分内容
ArrayList提供了subList(int fromIndex, int toIndex)方法来实现部分数据的截取。
可以从源码中看到其实是创建了一个SubList的内部对象，可以理解为是返回当前ArrayList的部分视图，其实指向的存放数据的还是一个地方。如果修改了subList返回的内容的话，原来的内容也会被修改。
public List<E> subList(int fromIndex, int toIndex) {
//检查需要截取的下标位置是否正确
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}其它方法
//判断ArrayList是否为空
public boolean isEmpty() {
return size == 0;
}
//反向查找元素位置，与上述的indexOf相反
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
//将元素全部拷贝到v中
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
//返回ArrayList拷贝后的Object数组
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
//返回ArrayList的模板数组。所谓模板数组，即可将T设置为任意数据类型
public <T> T[] toArray(T[] a) {
//若a的长度小于ArrayList中的元素个数，返回拷贝了ArrayList中全部元素的新数组
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
//若a的长度大于等于ArrayList中的元素个数，则将ArrayList中的元素全部拷贝到a中
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
//将ArrayList中的元素写入到输入流中，先写容量，在写元素
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
//从输入流中读取数据到elementData中，一样是先读容量，再读数据
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in capacity
s.readInt(); // ignored
if (size > 0) {
// be like clone(), allocate array based upon size not capacity
int capacity = calculateCapacity(elementData, size);
SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}7.小结
通过源码分析，ArrayList集合就是通过System.arraycopy方法将普通数组Object[]包装为一个动态数组，实现数组的增删改查。
1).ArrayList自己实现了序列化和反序列化，因为它实现了writeObject和readObject方法。
2).ArrayList基于数组实现，会自动扩容。
3).添加元素时会自己判断是否需要扩容，最好指定一个大概的大小，防止后面多次扩容带来的内存消耗；删除元素时不会减少容量，删除元素时，将删除掉的位置元素置为null，下次gc就会自动回收这些元素所占的空间。
4).ArrayList是线程不安全的。
5).使用iterator遍历可能会引发多线程异常。
优点：
1).ArrayList底层以数组实现，是一种随机访问模式，再加上它实现了RandomAccess接口，因此查找也就是get的时候非常快。
2).ArrayList在顺序添加一个元素的时候非常方便，只是往数组里面添加了一个元素而已。
3).根据下标遍历元素，效率高。
4).根据下标访问元素，效率高。
5).可以自动扩容，默认为每次扩容为原来的1.5倍。
6).修改元素和通过下标查询元素效率高。
7).集合是有顺序的。
缺点：
1).插入和删除元素的效率不高。
2).根据元素下标查找元素需要遍历整个元素数组，效率不高。
3).线程不安全。
4).删除元素效率低，因为要通过拷贝数组来实现。
5).大量新增效率低，因为大量新增的时候要不断进行扩容和数组的拷贝。
6)清除集合效率低，因为清除功能是通过循环数组进行清除的。
7).移除元素后，容量有大量剩余，需要手动调用trimToSize进行清理。
ArrayList常用优化方案
1).如果事先能够估算ArrayList需要的长度，可在构造时指定初始数组长度，节省扩容开销。
2).频繁调用void add(int index, E element)函数且指定下标位置靠前时，考虑转换为LinkedList。
3).调用boolean contains(Object o) 函数比较频繁时，可以考虑把元素放入HashSet里进行查询。
不要质疑你的付出，这些都会一种累积一种沉淀，它们会默默铺路，只为让你成为更优秀的人。感谢各位关注。
946
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
