ArrayList继承结构和层次关系
//源码中ArrayList类的继承和实现关系
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{源码文档注释 ：
⑴、类ArrayList是一个实现了接口List，底层实现是数组的一种列表。它有以下特点：
①、能根据需要调整自身容量的大小，完全解除了数组一旦创建就不能改变自身大小的限制(它提供了一些调整底层数组的方法，实际上，它仍然没有改变数组的大小，只是在需要的时候会重新创建一个新的数组，再将所有的元素复制到新数组中)。
②、实现了接口List的所有方法，能存储任何元素，包括null。
③、与类Vector类似(类Vector是线程安全的)，但是ArrayList不是线程安全的。
⑵、类ArrayList的以下方法的执行时间是一个常数(也就是一个固定的值，和存储元素的多少没有关系)：size()、isEmpty()、get() 、set() 、iterator() 、listIterator()。
方法add()的时间也是固定的，即添加一个元素的时间都是一样的。如果添加一个元素的时间为t，那么添加n个元素的时间则为nt。剩余其它方法的运行时间都是和元素个数成线性相关(也就是线性关系，如果元素的个数为n，每个元素的操作时间为t，那么连续操作n个元素的总时间y=nt+a，a是一个固定的常量，这个就是线性关系)。
类ArrayList与另一个列表类LinkedList相比，常数因子较低。也就是ArrayList较简单，在某些操作上花费的时间较少。
⑶、每个ArrayList实例对象都会用一个int类型的变量来存储当前列表底层数组的空间大小。它的值总是大于等于当前列表所存储的元素个数。随着新的元素对象添加到ArrayList实例对象中，这个表示数组存储空间的值会自动增长(实际就是一个更长的新数组替换了老的数组)。
⑷、在需要向一个ArrayList实例对象添加大量的元素之前，可以通过它的方法ensureCapacity(int minCapacity)一次性创建足够的存储空间，这样可以减少多次添加造成的内存开销(比如可能需要分三次添加9个元素，第一次添加3个，第二次添加3个，第三次添加3个，如果直接调用add方法添加，那么当前ArrayList对象实例会在第一次添加之前创建一个3个空间的数组，然后添加元素。在第二次添加之前会重新创建一个6个空间的数组，将之前的3个元素复制到它里面后再将之前的3个空间的数组对象丢弃，然后添加元素。在第三次添加之前会重新创建一个9个空间的数组，将之前的6个元素复制到它里面后再将之前的6个空间的数组对象丢弃，然后添加元素。方法ensureCapacity(int minCapacity)存在的意义是，在这种情况下，你可以使用它直接创建一个9个空间的数组，再进行添加元素的操作)。
⑸、类ArrayList的删除或者添加元素的方法实现未进行线程同步。如果有多个线程同时访问同一个ArrayList对象实例，并且至少有一个线程进行了删除或者添加元素的操作，那必须在它的外部进行线程同步。通常，通过自然封装列表的某个对象进行同步来完成此操作(比如通过关键字synchronize或者类Lock等方式)。
⑹、如果不存在这样一个自然封装列表的对象，则应该使用以下方式对ArrayList对象实例进行同步(通过类Collections的方法synchronizedList(new ArrayList(…)))：
// 对ArrayList列表对象进行同步
//通过类Collections的方法synchronizedList(List list)对
//ArrayList列表对象进行同步
List list = Collections.synchronizedList(new ArrayList(...));
最好是在创建ArrayList对象实例的时候就完成同步操作，可以防止对它的意外非同步访问。
⑺、类ArrayList的迭代器Iterator以及ListIterator都实现了快速失败机制(fail-fast)，如果在创建了迭代器对象后，通过除迭代器对象本身提供的其它方法修改了列表结构(比如添加、删除元素等)，将会引发ConcurrentModificationException异常(如果是通过迭代器对象本身提供的方法修改列表结构，则不会引发这个异常)。
⑻、类ArrayList不能完全保证快速失败机制一定会执行，通常来说，如果在不同步的情况下并发修改一个列表，快速失败机制无法做出任何严格的保证。 但是实现了快速失败机制的迭代器会尽最大努力抛出ConcurrentModificationException异常。因此，完全依赖快速失败机制来保证程序的正确性是错误的，快速失败机制应该仅用于检测错误。
继承实现关系：
ArrayList：说明ArrayList支持泛型。
extends AbstractList ：继承了AbstractList。为什么要先继承AbstractList，而让AbstractList先实现List？而不是让ArrayList直接实现List？
这里是有一个思想，接口中全都是抽象的方法，而抽象类中可以有抽象方法，还可以有具体的实现方法，正是利用了这一点，让AbstractList是实现接口中一些通用的方法，而具体的类， 如ArrayList就继承这个AbstractList类，拿到一些通用的方法，然后自己在实现一些自己特有的方法，这样一来，让代码更简洁，就继承结构最底层的类中通用的方法都抽取出来，先一起实现了，减少重复代码。所以一般看到一个类上面还有一个抽象类，应该就是这个作用。
实现了List接口：ArrayList的父类AbstractList也实现了List接口，那为什么子类ArrayList还是去实现一遍呢？collection 的作者Josh说他写这代码的时候觉得这个会有用处，但是其实并没什么用，但因为没什么影响，就一直留到了现在。
实现了RandomAccess接口：表明ArrayList支持快速（通常是固定时间）随机访问。在ArrayList中，我们可以通过元素的序号快速获取元素对象，这就是快速随机访问。
实现了Cloneable接口：实现了该接口，就可以使用Object.Clone()方法了。
implements java.io.Serializable：表明该类具有序列化功能，该类可以被序列化，什么是序列化？简单的说，就是能够从类变成字节流传输，然后还能从字节流变成原来的类。
类的属性
// 序列化id
private static final long serialVersionUID = 8683452581122892189L;
// 默认的初始化容量
private static final int DEFAULT_CAPACITY = 10;
// 指定该ArrayList容量为0时，返回该空数组。
private static final Object[] EMPTY_ELEMENTDATA = {};
// 当调用无参构造方法，返回的是该数组。刚创建一个ArrayList 时，其内数据量为0。
// 它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，而EMPTY_ELEMENTDATA是在
// 用户指定容量为时返回。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 保存添加到ArrayList中的元素。
// ArrayList的容量就是该数组的长度。
// 该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入ArrayList中时，
// 数组将扩容值DEFAULT_CAPACITY。
// 被标记为transient，在对象被序列化的时候不会被序列化。
transient Object[] elementData;
// ArrayList的实际大小（数组包含的元素个数/实际数据的数量）默认为0
private int size;
// 分派给arrays的最大容量
// 为什么要减去8呢？
// 因为某些VM会在数组中保留一些头字，尝试分配这个最大存储容量，可能会导致array容量
// 大于JVM的limit，最终导致OutOfMemoryError(请求的大小超出了JVM限制)。
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//备注：MAX.VALUE为0x7fffffff，转换成十进制就是2147483647，也就是数组的最大长度是2147483639；
构造方法
ArrayList提供了三种构造方法：
ArrayList的所有构造方法都必须要提供一个int类型的参数来指定底层数组的大小，无参的构造方法使用默认的大小，也就是10。
1. ArrayList(int initialCapacity)：构造一个指定容量为capacity的空ArrayList。这是一个带初始容量大小的有参构造函数。
> 初始容量大于0,实例化数组，将自定义的容量大小当成初始化elementData的大小
> 初始容量等于0，将空数组赋给elementData
> 初始容量小于0，抛异常
//构造具有指定初始容量的空List
//如果指定的初始容量为负，抛出异常
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);
}
}
2. ArrayList()：构造一个初始容量为 10 的空列表。创建ArrayList对象的时候不传入参数，则使用此无参构造方法创建ArrayList对象。有元素被加入时(add方法).当进行第一次add的时候，elementData将会变成默认的长度：10。
//构造一个初始容量为10的空列表
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
3. ArrayList(Collection<? extends E> c)：
这个构造方法的意思是，将一个Collection实现类的对象转换为一个ArrayList，但是c容器装的内容必须为ArrayList装的内容的子类。例如，将一个装了String内容的HashSet转换为装了String内容的ArrayList，使得ArrayList的大小和值数组都是HashSet的大小和值数组。具体实现如下代码，首先调用c(Collection的具体实现类)的toArray方法，具体大家可以看各个实现类的toArray方法，但是大概意思都是将c容器转换为object类型的数组，因为它们的返回值都是object[]。之于下面的两个判断是当得到的elementData的类名不是Object类名的时候或者是长度为0的时候才会执行。
/**
* 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器
* 返回它们的顺序排列的。
* 其元素将放置在此列表中的 collection
* @throws NullPointerException如果指定的 collection 为 null
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
//每个集合的toarray()的实现方法不一样，所以需要判断一下，如果不是
//Object[].class类型，那么就需要使用ArrayList中的方法去改造一下。
if (elementData.getClass() != Object[].class)
//copyOf(要复制的数组,要返回的副本的长度,要返回的副本的类)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
ArrayList的构造方法就做一件事情，就是初始化一下储存数据的容器，其实本质上就是一个数组，在其中就叫elementData。
结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
主要方法介绍：
get()方法
/**
* 返回list中指定位置的元素
* @throws IndexOutOfBoundsException
*/
public E get(int index) {
rangeCheck(index);//越界检查
return elementData(index);//返回索引为index的元素
}
/**
检查指定索引是否在范围内。如果不在，抛出一个运行时异常。
这个方法不检查索引是否为负数，它总是在数组访问之前立即优先使用，
如果给出的索引index>=size，抛出一个越界异常
*/
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
// 返回索引为index的元素
E elementData(int index) {
return (E) elementData[index];
}
从代码中可以看到，因为ArrayList底层是数组，所以它的get方法非常简单，先是判断一下有没有越界（索引小于0或者大于等于数组实际长度，错误信息返回索引和数组的实际长度），之后就直接通过数组下标来获取元素。
set()方法
/**
* 用指定的元素替换列表中指定位置的元素。
* @return先前位于指定位置的元素(返回被替换的元素)
* @throws IndexOutOfBoundsException如果参数指定索引index>=size，抛出一个越界异常
*/
public E set(int index, E element) {
//检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常
rangeCheck(index);
//记录被替换的元素（旧值）
E oldValue = elementData(index);
//替换元素（新值）
elementData[index] = element;
//返回被替换的元素
return oldValue;
}
确保set的位置小于当前数组的长度（size）并且大于0，获取指定位置（index）元素，然后放到oldValue存放，将需要设置的元素放到指定的位置（index）上，然后将原来位置上的元素oldValue返回给用户。
add()方法
boolean add(E e)：在list的末尾添加一个元素
//将指定的元素追加到此列表的末尾
public boolean add(E e) {
//确认list容量，如果不够，容量加1。注意：只加1，保证资源不被浪费
ensureCapacityInternal(size + 1); // Increments modCount!!
//将元素e放在size的位置上,并且size++
elementData[size++] = e;
return true;
}
//数组容量检查，不够时则进行扩容，只供类内部使用
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//若elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则取minCapacity为
//DEFAULT_CAPACITY和参数minCapacity之间的最大值。DEFAULT_CAPACITY在此之前
//已经定义为默认的初始化容量是10。
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//数组容量检查，不够时则进行扩容，只供类内部使用
// minCapacity 想要的最小容量
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
//最小容量>数组缓冲区当前长度
if (minCapacity - elementData.length > 0)
grow(minCapacity);//扩容
}
size是数组中数据的个数，因为要添加一个元素，所以size+1，先判断size+1的这个个数数组能否放得下。calculateCapacity方法用来计算容量。判断初始化的elementData是不是空的数组，如果是空数组长度size就是0，否则数组长度就不是0。
> 如果elementData元素是空的，就是第一次添加元素，minCapacity=size+1，其实就是等于1， 空的数组没有长度就存放不了，所以就将minCapacity变成10，也就是默认容量的大小。也就是 elementData数组的此时需要的最小容量为变10了，此时ensureExplicitCapacity()方法中的 minCapacity就是10。到此只是说elementData数组需要的容量至少是10，还没有改变 elementData的大小。
> 如果elementData数组中的元素不是空的，那么它此时需要的最小容量就是原先的数组长度加 1，minCapacity代表着elementData中元素增加之后的实际数据个数。
> 要始终记住minCapacity = size+1,在ensureExplicitCapacity()方法中，首先操作数自增1，再把 需要的最小空间容量与数组当前实际长度进行比较：
> 如果elementData中的元素是空的，它现在需要的容量是10，但是elementData.length为 0，所以要扩容。
> 如果elementData数组中的元素不是空的，若它添加一个元素后需要的容量比原数组长度 大，就需要扩容，否则就不需要扩容。
ArrayList能自动扩展大小的关键方法就在下面的grow()方法里：
/**
* 扩容，保证ArrayList至少能存储minCapacity个元素
* 第一次扩容，逻辑为newCapacity = oldCapacity + (oldCapacity >> 1);即在原有的容量基础
* 上增加一半。
* 第一次扩容后，如果容量还是小于minCapacity，就将容量扩充为minCapacity。
*/
private void grow(int minCapacity) {
// overflow-conscious code
// 获取当前数组的容量
int oldCapacity = elementData.length;
// 扩容。新的容量=当前容量+当前容量/2.即将当前容量增加一半（当前容量增加1.5倍）。
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果扩容后的容量还是小于想要的最小容量
if (newCapacity - minCapacity < 0)
//将扩容后的容量再次扩容为想要的最小容量
newCapacity = minCapacity;
//elementData就空数组的时候，length=0，那么oldCapacity=0，newCapacity=0，
//在这里就是真正的初始化elementData的大小了，就是为10.
//如果扩容后的容量大于临界值，则进行大容量分配
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
//新的容量大小已经确定好了，就copy数组，改变容量大小。
//copyof(原数组，新的数组长度)
elementData = Arrays.copyOf(elementData, newCapacity);
}
//进行大容量分配
private static int hugeCapacity(int minCapacity) {
//如果minCapacity<0，抛出异常
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
//如果想要的容量大于MAX_ARRAY_SIZE，则分配Integer.MAX_VALUE，否则分配MAX_ARRAY_SIZE
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
综合以上在list末尾追加数据的方法，如果原数组是空的，添加1个元素时数组容量变为10，如果原数组不为空，追加元素时容量变为原来的1.5倍。如果扩容后的容量大于分配给ArrayList的容量，判断需要的容量是否比分派的容量大，是就把Integer.MAX_VALUE:2147483647赋值给minCapacity，否就用MAX_ARRAY_SIZE：2147483639。
调用add方法时，函数调用过程如下：
程序调用add，如果需要扩容就可能会调用到grow，grow可能会调用hugeCapacity。
例1（扩容的情况）：
List<Integer> lists = new ArrayList<Integer>();
lists.add(8);初始化lists大小为0，调用的ArrayList()的空参构造函数，那么在调用lists.add(8)方法时，经过的步骤如下：
可以看到，在add方法之前开始elementData = {}；调用add方法时会继续调用，直至grow，最后elementData的大小变为10，之后再返回到add函数，把8放在elementData[0]中。
例2（不扩容的情况)：
List<Integer> lists = new ArrayList<Integer>(6);
lists.add(8);调用的ArrayList(int)型构造函数，initialCapacity 等于 6，elementData = new Object[6]，elementData被初始化为大小为6的Object数组，在调用add(8)方法时，具体的步骤如下：
在调用add方法之前，elementData的大小已经为6，之后再进行传递，不会进行扩容处理。
void add(int index, E element)
/**
* 将指定元素插入到列表中的指定位置。将当前位于该位置的元素(如果有的话)和随后的任何元素
* 向右移动(将一个元素添加到它们的索引中)。
* @throws IndexOutOfBoundsException 如果索引超出size
*/
public void add(int index, E element) {
//越界检查
rangeCheckForAdd(index);
//确认list容量，如果不够，容量加1。注意：只加1，保证资源不被浪费
ensureCapacityInternal(size + 1);
// 对数组进行复制处理，目的就是空出index的位置插入element，并将index后的元素
// 位移一个位置
//在插入元素之前，要先将index之后的元素都往后移一位
//arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制
//的数组元素的数量)
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//将指定的index位置赋值为element
elementData[index] = element;
//实际容量+1
size++;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)//插入的位置不能大于size 和小于0，如果是就报越界异常
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
在指定的位置添加元素，也就是插入元素。
举例：在索引2处添加元素e,大概过程如下：
add(int index, E e)需要先对元素进行移动，然后完成插入操作。
remove()方法
根据索引remove,通过删除指定位置上的元素
/**
*删除list中位置为指定索引index的元素
* @throws IndexOutOfBoundsException指定索引index>=size，抛出一个越界异常
*/
public E remove(int index) {
//检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常
rangeCheck(index);
//结构性修改次数+1
modCount++;
//记录索引处的元素
E oldValue = elementData(index);
// 删除指定元素后，需要左移的元素个数
int numMoved = size - index - 1;
//如果有需要左移的元素，就移动（移动后，该删除的元素就已经被覆盖了）
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//size--，然后将索引为size-1处的元素置为null。为了让GC起作用，必须显式的
//为最后一个位置赋null值
elementData[--size] = null;
//返回被删除的元素
return oldValue;
}
根据索引删除元素的步骤：
1.进行越界检查
2.记录修改次数（modCount 可以用来检测快速失败的一种标志。）
3.通过索引找到要删除的元素
4.计算要移动的位数
5.移动元素（其实是覆盖掉要删除的元素）
6.将–size上的位置赋值为null，让gc(垃圾回收机制)更快的回收它。
7.返回被删除的元素
根据对象remove
/**
* 从列表中删除指定元素的第一个出现项,如果它存在的话。如果列表不包含该元素,
* 它将保持不变。更正式地说，删除索引最低的元素
*/
public boolean remove(Object o) {
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;
}
//私有的remove方法，该方法跳过边界检查，并且不返回已删除的值。
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
//arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制的数组元素的数量)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null;
}
循环遍历所有对象，得到对象所在索引位置，然后调用fastRemove方法，执行remove操作。
定位到需要remove的元素索引，先将index后面的元素往前面移动一位（调用System.arraycooy实现），然后将最后一个元素置空。
这里最主要是知道arrayList可以存储null值。
removeRange(int fromIndex, int toIndex)
/**
* 从该列表中删除索引位于两者之间的所有元素，包含fromIndex，但是不包含toIndex，
* 将任何后续元素向左移动(减少它们的索引)
* 这个调用通过(toIndex - fromIndex)元素缩短列表。
*(如果{@code toIndex==fromIndex}，此操作无效。)
* @throws IndexOutOfBoundsException if
* (fromIndex < 0 ||
* fromIndex >= size() ||
* toIndex > size() ||
* toIndex < fromIndex})
*/
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;//被删除的索引后面的个数
//arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，
//要复制的数组元素的数量)
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// clear to let GC do its work
int newSize = size - (toIndex-fromIndex);//新数组的长度
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}
此方法删除fromIndex到toIndex之间的全部元素，把toIndex以后的元素移动（size-toIndex）位，把左移后空的元素置为null好让垃圾回收机制回收内存，最后把新数组的大小赋值给size。
indexOf()和lastIndexOf()方法
//返回此列表中指定元素的第一个出现项的索引，如果该列表不包含该元素，则返回-1。
public int indexOf(Object o) {
if (o == null) { // 查找的元素为空
for (int i = 0; i < size; i++) // 遍历数组，找到第一个为空的元素，返回下标
if (elementData[i]==null)
return i;
} else { // 查找的元素不为空
for (int i = 0; i < size; i++) // 遍历数组，找到第一个和指定元素相等的元素，返回下标
if (o.equals(elementData[i]))
return i;
}
return -1;
}
//返回此列表中指定元素的最后一次出现的索引，如果该列表不包含该元素，则返回-1。
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;
}
subList(int fromIndex, int toIndex)
//public方法,供对象实例调用
//返回类型为List<E>,带两个int类型的形式参数fromIndex和toIndex
//它的作用是：根据指定索引值指定的范围返回当前列表的一个子列表
//也可以成为返回当前列表的一个视图。
//fromIndex(包含),toIndex(不含)
public List<E> subList(int fromIndex, int toIndex) {
//保证索引值fromIndex和toIndex的合法性
subListRangeCheck(fromIndex, toIndex, size);
//返回一个内部类SubList对象。
//同时将当前列表对象this,0,fromIndex,toIndex作为实际参数传入。
return new SubList(this, 0, fromIndex, toIndex);
}
trimToSize()
//public方法,供对象实例调用
//返回类型为void,不带任何的形式参数
//它的作用是：与方法ensureCapacity(int minCapacity)
//配合使用,一旦方法ensureCapacity(int minCapacity)创建的空间
//在添加完元素后还有多余,将多余的空间回收
public void trimToSize() {
//从抽象类AbstractList<E>继承的类变量,它的值的变化代表着
//当前列表结构的更改,与快速失败机制有关。
//将类变量modCount的值+1
modCount++;
//如果实际存储的元素数量(size)小于elementData的长度,
//说明有多余的存储空间
if (size < elementData.length) {
//如果elementData没有存储任何元素,
//也就是size == 0,那么将EMPTY_ELEMENTDATA赋值给elementData
//将原数组丢弃.供垃圾回收器回收
//如果size != 0,则通过类Arrays的方法copyOf(T[] original, int newLength)
//重新创建一个原元素数量刚好合适的数组.将原数组丢弃...
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
//有兴趣可以查看类Arrays的方法
//public static <T> T[] copyOf(T[] original, int newLength)
}
}
ensureCapacity(int minCapacity)
//public方法,供对象实例调用
//返回类型为void,带一个int类型的形式参数minCapacity
//它的作用是：重新创建一个包含minCapacity个空间的数组来替换
//当前的数组,并将当前数组的所有元素复制到新数组。
//在预先知道即将要存储的元素个数的前提下,可以使用这个方法一次性
//扩容足够的存储空间。
public void ensureCapacity(int minCapacity) {
//这行代码的作用就是判断minCapacity与DEFAULT_CAPACITY的大小
//你始终需要牢记数组是不能改变大小的。所谓的扩容都是重新创建一个
//更长的数组来代替原先更短的数组,还要把元素都复制到新数组中
//如果minCapacity的值比默认的DEFAULT_CAPACITY都更小,就没有
//扩容的必要了。
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
? 0
: DEFAULT_CAPACITY;
//如果minCapacity大于minExpand
if (minCapacity > minExpand) {
//调用方法ensureExplicitCapacity(int minCapacity)
//对数组进行扩容。
ensureExplicitCapacity(minCapacity);
}
}
//为什么要设置minExpand?
//这个变量,实际上存在两种情况,如果elementData ==
//DEFAULTCAPACITY_EMPTY_ELEMENTDATA,就说明目前底层数组没有任何的元素
//那么就肯定要比较参数minCapacity与DEFAULT_CAPACITY的大小
//如果DEFAULT_CAPACITY比minCapacity更大,就不需要再扩容。
//如果DEFAULT_CAPACITY比minCapacity更小,就需要重新创建
//一个minCapacity大小的数组来代替默认为DEFAULT_CAPACITY的数组。
elementData(int index)
//public方法,供对象实例调用
//返回类型为E,带一个int类型的形式参数index
//它的作用是：返回指定索引index的元素E(E代表的是运行时类型)
E elementData(int index) {
//利用数组通过索引返回元素的方式返回索引为index的元素,
//并使用了强制转型,转换为E类型(E代表的是运行时类型)
return (E) elementData[index];
}
listIterator(int index)
//public方法,供对象实例调用
//返回类型为ListIterator<E>,带一个int类型的形式参数index
//它的作用是：返回一个从当前列表指定索引位置index开始迭代元素的迭代器对象
//这个迭代器设置了快速失败机制。
public ListIterator<E> listIterator(int index) {
//如果index的值小于0或者大于size
if (index < 0 || index > size)
//抛出IndexOutOfBoundsException异常
throw new IndexOutOfBoundsException("Index: "+index);
//返回一个内部类ListItr的对象实例.同时将index作为实际参数传入。
return new ListItr(index);
}
listIterator()
//public方法,供对象实例调用
//返回类型为ListIterator<E>,不带任何形式参数
//它的作用是：返回一个从头开始迭代元素的迭代器对象
//这个迭代器设置了快速失败机制。
public ListIterator<E> listIterator() {
//返回一个内部类ListItr的对象实例.同时将0作为实际参数传入。
//0为数组第一个元素的索引位置
return new ListItr(0);
}
iterator()
//public方法,供对象实例调用
//返回类型为Iterator<E>,不带任何形式参数
//它的作用是：返回当前列表对象的通用迭代器对象
//Iterator是通用的迭代器类型
//这个迭代器设置了快速失败机制。
public Iterator<E> iterator() {
//返回一个内部类Itr的对象实例
return new Itr();
}
总结：
1）arrayList可以存放null。
2）arrayList本质上就是一个elementData数组。
3）arrayList区别于数组的地方在于能够自动扩展大小，其中关键的方法就是gorw()方法。
4）arrayList中removeAll(collection c)和clear()的区别就是removeAll可以删除批量指定的元素，而clear是全是删除集合中的元素。
5）arrayList由于本质是数组，所以它在数据的查询方面会很快，而在插入删除这些方面，性能下降很多，有移动很多数据才能达到应有的效果。
6）arrayList实现了RandomAccess，所以在遍历它的时候推荐使用for循环。
7）jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存
扫一扫
470
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
