（注意：本文基于JDK1.8）
ArrayList类结构
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
}1、ArrayList是一个范型类
2、ArrayList的直接父类是AbstractList
3、ArrayList实现了List接口、RandomAccess接口、Cloneable接口、Serializable接口
List接口介绍
List接口继承Collection接口，定义了作为一个线性表应该具备哪些功能！
List接口定义作为一个线性表应该具备哪些能力（功能）：
add（）：增加一个元素（末尾）
add（int）：在指定下标处增加一个元素
addAll（Collection）：增加多个元素
addAll（int，Collection）：从指定下标处增加多个元素
clear（）：清空所有元素
contains（Object）：是否包含某个元素
containsAll（Collection）：是否包含多个元素
get（int）：通过指定的下标获得一个元素
indexOf（Object）：获取第一个匹配元素的下标（从数组头部开始寻找）
lastIndexOf（Object）：获取第一个匹配元素的下标（从数组尾部开始寻找）
listIterator（）：获取一个从数组头部开始的迭代器
listIterator（int）：获取一个从指定下标开始的迭代器
remove（int）：删除指定下标的元素，并获得此元素
remove（Object）：删除匹配的元素，并获得删除结果
removeAll（Collection）：删除多个匹配的元素，并获得删除结果
replaceAll（）：替换匹配的元素
retainAll（）：获取交集后的结果
set（int，Object）：修改指定下标的元素
size（）：获取ArrayList持有的元素总数
sort（Comparator）：用于排序所有元素，排序规则由传入的Comparator对象限制
spliterator（）：获取一个迭代器
subList（int，int）：获取一个指定开始下标与结束下标的list
toArray（）：将List转换成一个数组对象
三个标记接口介绍
ArrayList实现的三个接口均为标记接口，这些接口中没有定义任何抽象方法
RandomAccess：表示ArrayList支持下标访问元素
Cloneable：表示ArrayList支持clone对象
Serializable：表示ArrayList支持对象序列化操作
ArrayList底层原理与时间复杂度
1、基于数组，常常称ArrayList为动态数组，因为每个ArrayList对象都持有的1个elementData数组对象用来保存添加的元素，ArrayList的优点是不必担心元素无空间可放，它支持对底层数组容量的自动扩充，每次数组扩容（数组扩充容量）时会将原数组中的所有元素，逐个拷贝到新的数组中（注意：数组中存储的是元素对象的引用）
2、ArrayList只能在单线程下使用
3、在元素操作的性能上与数组一致
元素插入尾部：O（1）
元素插入中间：O（n）
删除尾部元素：O（1）
删除中间元素：O（n）
修改元素（下标）：O（1）
查找元素：O（n）
访问元素（下标）：O（1）
ArrayList字段介绍
1、常量serialVersionUID
private static final long serialVersionUID = 8683452581122892189L;
该常量用于校验反序列化对象时的平台一致性，取出二进制字节流中的serialVersionUID值与JVM内存中已经加载的class中的serialVersionUID值进行比较，如果一致则通过，否则抛出InvalidCastException异常，注意该方式为手工指定方式serialVersionUID，另外一种是自动方式，由JVM根据类结构生成hashCode
2、常量DEFAULT_CAPACITY
private static final int DEFAULT_CAPACITY = 10;
表示底层数组的默认容量为10
3、常量EMPTY_ELEMENTDATA
private static final Object[] EMPTY_ELEMENTDATA = {};
EMPTY_ELEMENTDATA，该常量指向一个空的数组对象，元素类型是Object，它用于区分创建ArrayList对象的方式
4、常量DEFAULTCAPACITY_EMPTY_ELEMENTDATA
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
DEFAULTCAPACITY_EMPTY_ELEMENTDATA，另外一个空的数组对象，元素类型也是Object，它用于区分创建ArrayList对象的方式
5、实例变量elementData
transient Object[] elementData;
该实例变量指向的是实际用于存储元素的底层数组对象，ArrayList全靠这个数组对象，使用transient修饰表示不参与对象序列化
6、实例变量size
private int size;
实例变量size，表示ArrayList中已经添加元素的总数，默认值为0
7、父类中的实例变量modCount
protected transient int modCount = 0;
实例变量modeCount,此实例变量定义在父类AbstractList中，表示操作行为的改变次数，每当添加、删除、修改元素时，它的值均会+1，是实现fail-fast机制的重要成员
ArrayList构造方法回顾
ArrayList的三个构造方法
1、无参数的构造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}对elementData进行了赋值，它指向先前创建好的DEFAULTCAPACITY_EMPTY_ELEMENTDATA数组对象
2、传入一个Collection对象的构造方法
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}接受一个Collection集合，并要求该Collection的元素类型与ArrayList的元素类型必须一样，均为E或者E的子类，首先将传入的Collection集合转换为数组对象，并赋值给elementData，然后先取出elementData数组的长度并赋值给size变量，然后拿size的值与0进行比较，即检查elementData指向的数组对象是否有元素，如果里面有元素的话，先通过elementData.getClass()拿到数组对象的类型（一个Class对象），接着确认elementData是否为Object[]类型，如果不是的话，将elementData、size、Object[].class，一起传入到Arrays.copyOf方法里，该方法会根据你传入的数组类型，返回一个新的数组对象，此时elementData就指向一个全新的数组对象。如果你传入的Collection对象里压根就没有元素，则会执行this.elementData = EMPTY_ELEMENTDATA，这里又用到了之前定义的EMPTY_ELEMENTDATA。
作者对于DEFAULTCAPACITY_EMPTY_ELEMENTDATA、EMPTY_ELEMENTDATA这两个定义好的对象，分别在不同的构造方法里进行了使用，目的是为何呢？继续往下看吧
3、传入一个int表示初始化容量的构造方法
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);
}
}接受一个initialCapacity，表示底层数组的初始化容量，此时initialCapacity大于0，我们将创建一个Object数组对象并赋值给elementData，若initialCapacity等于0，则为elementData赋值为EMPTY_ELEMENTDATA这个预先创建好的Object数组对象，又一次看见了它，最后若initialCapacity小于0，则会抛出一个IllegaArgumentException的异常
ArrayList添加元素回顾
ArrayList中实现4个添加元素的方法，分别代表：添加一个元素、指定下标处添加一个元素、添加多个元素、指定下标处添加多个元素
1、add（E）方法
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}add（E e）方法，这是我们最常用的添加元素的方法，它接受一个元素e，方法体里面首先调用了ensureCapacityInternal方法，传入的参数是size+1， size代表的是当前已经添加的元素总数，此时我们想再添加1个元素，所以传入size+1，就是想看看现有数组能不能再添加1个元素，ensureCapacityInternal方法则用于确认数组的内部容量是否需要扩容，后面我们会重点分析一下ensureCapacityInternal方法；当首次添加元素时，size的默认值是0，此时elementData[size++] = e处做了两件事，第一是将元素e添加到elementData数组的下标0处（size当前值），接着就对size进行+1操作，那size不但代表已添加元素的总数，还代表以后在数组尾部新添加元素的下标值，这里作者用的很巧妙，最后return ture代表添加元素成功
2、add（int，E）方法
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}add（int index，E element）方法，是在指定下标处添加元素，该方法接受两个参数，index代表下标，element代表要添加的元素，首先判断index不能超出的两个范围，第一是index不可以大于size（元素总数）、第二是index不能小于0，超出范围的结果是会抛出IndexOutOfBoundException异常，比如现在ArrayList已经添加了5个元素，此时size==5，那么你的index值范围必须为0 < index <= 5；index值符合要求的话，会接着执行ensureCapacityInternal方法，传入参数仍为size+1，判断底层数组需要扩容；无需扩容或扩容完毕，则就要给即将添加的元素element挪开空间，System.arraycopy方法就是负责挪开空间的方法
3、addAll（Collection）方法
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}addAll方法，接受一个Collection对象，会将元素一个一个的依次添加到当前的底层数组中，首先将Collection转为Object数组，然后获取该Object数组的元素数量，为ensureCapacityInternal方法传入一个当前元素总数（size）+ Object数组总数（newNum）的和，来进行扩容判断，保证底层数组能把所有元素保存下来，确认完底层数组容量后，开始将Object数组的元素一个一个的添加进底层数组中（又一次用到System.arraycopy方法），举个例子，当前数组为【"fk"，"you"，"hello"，"world"，null，null，null，null】，此时添加有3个元素的Collection【"ni"，"hao"，"ma"】，则当前数组更新为【"fk"，"you"，"hello"，"world"，"ni"，"hao"，"ma"，null】，可以看到是从size处开始添加的，添加完毕后，同样要更新已有元素的总数，size+numNew即为元素总数，只要添加的Collection的元素总数不为0，返回值代表添加成功
4、addAll（int，Collection）方法
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}addAll(int index,Collection<? extends E> c)，则是指定起始下标处添加多个元素的方法，首先判断index下标的是否超出范围，大于元素总数或小于0，会立刻抛出IndexOutOfBoundsException异常，该异常对象创建时，还先调用了一个outOfBoundsMsg方法，它接受了index下标，返回值应该是一个字符串对象。若index符合范围要求，仍是先将Collection转为Object数组对象，取出Object数组对象的长度赋值给newNum，继续size+numNum传入到ensureCapacityInternal中，判断当前底层数组的容量能否满足当前需求，当确认完当前底层数组容量（扩容或不用扩容）能满足添加元素的需求，马上计算要拖动元素的数量，size - index，比如一共有6个元素，此时要在下标3处添加元素， 6 - 3 = 3，此时需要挪动3个元素。numMoved就保存了要挪动（复制）元素的数量，此刻判断numMoved大于0，又进行一次数组复制，目的是为了腾出空间，所谓腾出空间，就是把原来的数组元素复制到别的地方，这样原来数组的位置，就可以用来添加新的元素了，我觉得这里很适合画一幅图出来。连续两次调用System.arraycopy，第一次是为了腾出空间（只是依次把需要挪动元素的元素都复制了一份到别处），第二次是把Object数组对象的中元素，正式复制到底层数组腾出空间的位置处，反回值代表添加元素是否成功，只要添加数量大于0个，就算成功
System中的拷贝数组元素方法
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
src 源数组对象
srcPos 源数组对象的起始下标
dest 目标数组对象
destpos 目标数组对象的起始下标
length 元素数量
ArrayList删除元素
四个删除元素的方法
一个清空元素的方法
1、remote（int）方法
public E remove(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
modCount++;
E oldValue = (E) elementData[index];
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
return oldValue;
}remove（int index），根据指定的下标删除元素，首先判断下标是否超出已添加元素的下标范围，index大于等于size，直接抛出IndexOutOfBoundsException，index下标符合范围的情况下，首先modCount进行+1，然后先取出来旧元素，并复制到oldValue中，接着计算要挪动元素的数量（size - index - 1），比如已经添加了6个元素，干掉index == 3的元素，6 - 3 - 1 == 2，计算两个元素需要挪动（向前挪动），System.arrayCopy并非是真的挪动元素，它只是把index后面的元素一个一个的向前复制一下。举个例子，目前数组情况是【"first"，"second"，"third"，"fourth"，"fifth"，"sixth"】，共计6个元素，此时我们把下标3的元素"fourth"删除掉，那么就需要把"fourth"后面的两个元素都各自向前挪动一位，因为采用的是System.array方法，所以经过第一次的调用，则为【"first"，"second"，"third"，"fifth"，"sixth"，"sixth"】，只不过是把原来的"fourth"覆盖掉了，最后一个元素，当然还在，所以才有后面的一句elementData[--size] = null，不仅更新的元素总数，还把最后一个元素赋值为null，等待以后GC把该对象回收掉，目前来看是不会有任何回收的，但都是为了以后作准备，如果不做null这一步，那么该数组持有的元素对象，无法得到回收！【"first"，"second"，"third"，"fifth"，"sixth"，null】，这才是最后的结果，最后该方法返回移除元素的值，妙哉妙哉
2、remove（Object）方法
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(Object o)，根据元素对象本身做对比然后进行删除操作，因为ArrayList支持添加null元素，所以该方法分成了两部分业务逻辑，一个是对null元素的删除操作，另一个就是对非null元素的对比删除操作。先看下null元素的删除，从底层数组下标0处开始遍历，一直到小于size（元素总数）处截止，只要有一个元素匹配，就直接做删除操作，停止遍历并然后返回删除成功；下面是对象的对比，也是从下标0处开始遍历，只要找到符合相等的元素，此处是用equals方法比较，只要相等就做删除操作并停止遍历，接着马上返回删除成功。若null元素或者非null元素均没有找到有相等的元素存在，则直接返回false，代表删除失败
3、removeAll（Collection）方法
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}removeAll（Collection<?> c），批量删除元素，内部又调用了batchRemove方法，第二个参数是boolean值，可见它里面的业务逻辑支持两种方式（true or false）
4、removeIf（Predicate）方法
public boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
// figure out which elements are to be removed
// any exception thrown from the filter predicate at this stage
// will leave the collection unmodified
int removeCount = 0;
final BitSet removeSet = new BitSet(size);
final int expectedModCount = modCount;
final int size = this.size;
for (int i=0; modCount == expectedModCount && i < size; i++) {
@SuppressWarnings("unchecked")
final E element = (E) elementData[i];
if (filter.test(element)) {
removeSet.set(i);
removeCount++;
}
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
// shift surviving elements left over the spaces left by removed elements
final boolean anyToRemove = removeCount > 0;
if (anyToRemove) {
final int newSize = size - removeCount;
for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
i = removeSet.nextClearBit(i);
elementData[j] = elementData[i];
}
for (int k=newSize; k < size; k++) {
elementData[k] = null; // Let gc do its work
}
this.size = newSize;
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}
return anyToRemove;
}JDK1.8中新增加的方法，接受一个Predicate对象，代表过滤规则，如果符合规则的元素将被删除掉
5、clear（）方法
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}清空行为的特点是把所有元素都删除掉，先把modCount++，标记着这也算是改变元素的行为，然后遍历底层数组中所有已添加元素，将每一个下标都赋值为null，元素对象的强引用被干掉后，GC就自然会把所有的元素都删除了，最后把元素总数size赋值为0
ArrayList修改元素回顾
public E set(int index, E element) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
E oldValue = (E) elementData[index];
elementData[index] = element;
return oldValue;
}set(int index, E element) 是重写的AbstractList中的set方法，AbstractList中的set方法定义直接就抛出一个异常（看下面）。首先仍然先对index的范围作出判断， >=size时将直接抛出IndexOutOfBoundsException，因为现有的元素不可能等于size，最后一个已添加的元素下标是size - 1，范围满足要求的情况下，首先从index下标处取出存储的值（一个对象的引用）赋值给oldValue，然后为index下标修改为新元素，最后返回旧元素的引用oldValue
public E set(int index, E element) {
throw new UnsupportedOperationException();
}AbstractList实现的set方法，直接抛出一个UnsopportedOperationException异常
ArrayList查找元素回顾
public E get(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
return (E) elementData[index];
}get(int index),通过传入的下标index获得元素，首先仍是判断index是否超出范围，即大于等于size，就抛出异常IndexOutOfBoundsException（outOfBoundsMsg（index）），其中outOfBoundsMsg（index）方法会先执行并返回一行字符串（这都是为了客户端开发），符合要求的话后面就很直接了，直接取出index下标的元素，并进行向下转型，毕竟elementData是Object数组，而这里需要返回实际类型
判断ArrayList是否为空
public boolean isEmpty() {
return size == 0;
}isEmpty()，返回当前List是否为空
获取ArrayList持有的元素总数
public int size() {
return size;
}size（），返回元素总数
ArrayList查找指定元素的下标
有下标就能通过get（Object o）方法返回实际的元素对象，那么如何获取一个元素的下标呢？大佬提供下面两个API！！
indexOf：从前向后查找匹配元素的下标，只要命中就返回
lastIndexOf：从后向前查找匹配元素的下标，也是命中方法就返回
1、indexOf（Object）方法
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;
}indexOf(Object o)，因为ArrayList支持null元素，所以这里也是严格区分为null元素的处理，以及实际对象的处理，null元素通过==进行比较判断，从下标0开始遍历，第一次匹配的元素的下标会被返回；实际对象元素则是通过equals（）方法进行比较判断，也是从下标0开始遍历，直到碰到匹配的元素，并返回下标；若最后元素没有找到匹配的，则会返回-1
2、lastIndexOf（Object）方法
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;
}lastIndexOf(Object o) 则是从数组中的最后一个元素向第一个元素的方法进行遍历，除此之外逻辑与indexOf相同，这里就不再多说了
ArrayList迭代器回顾
迭代器用于遍历ArrayList，四个方法均能获得一个迭代器对象
1、iterator（）方法
public Iterator<E> iterator() {
return new Itr();
}iterator（）方法，返回一个Itr对象，Itr是Iterator的实现类，Itr对象是最基本的迭代器对象，可以满足遍历元素的需求
2、listIterator（）方法
public ListIterator<E> listIterator() {
return new ListItr(0);
}listIterator()方法也返回一个迭代器对象，ListIterator接口继承了Iterator接口，而返回的ListItr对象，则是Listiterator的实现类，一个增强型的迭代器对象，默认为ListItr的构造方法传入的是0，代表遍历元素时的起始下标
3、listIterator（int）方法
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}listIterator(int index)，可以指定迭代器在遍历时的起始下标（从哪个元素开始遍历），首先对index做范围检查，如果小于0或者大于size（元素总数），则直接抛出IndexOutOfBoundsException对象，检查index通过后，则会返回ListItr对象
ArrayList扩容机制回顾
ArrayList对外提供一个方法支持手工触发扩容，后面两个私有方法均为插入元素时会触发的扩容方法
1、ensureCapacity（int）方法
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}ensureCapacity(in minCapacity)，是我们可以手动调用的扩容方法，传入的minCapacity代表需要的最小容量，DEFAULTCAPACITY_EMPTY_ELEMENTDATA在这里有了它的用处，若elementData并没有指向该对象时，则minExpand的值为0，minExpand代表已经扩容后最小数量，若elementData指向了DEFAULTCAPACITY_EMPTY_ELEMENTDATA对象，则minExpand最小也已经扩容后的最小数量是10（DEFAULT_CAPACITY的值），若需要的最小容量minCapacity大于已经扩容后的最小数量minExpand，则进行到下一步，调用ensureExplicitCapacity方法，后面讲ensureExplicitCapacity方法
2、ensureCapacityInternal（int）方法
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}ensureCapacityInternal（int minCapacity），是我们添加元素的时候，必会调用的方法，这一次DEFAULTCAPACITY_EMPTY_ELEMENTDATA仍然有用处，若当前的elementData指向的与DEFAULTCAPACITY_EMPTY_ELEMENTDATA是同一个数组对象，则将传入的minCapacity与DEFAULT_CAPACITY(值为10)，进行对比，两者之间的较大值作为minCapacity的值，可见若未指定默认容量的ArrayList对象第一次进行扩容时的数组容量就是10！！！！最后也会调用ensureExplicitCapacity，往后看
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; //这是elementData指向该对象的唯一一次赋值
}
3、ensureExplicitCapacity（int）方法
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}前面两个ensure方法均是确认一个需要的数组最小容量，最后都传给ensureExplicitCapacity（int minCapacity）方法，它接受一个最小容量minCapacity，首先modCount++，没想到不单单是添加元素、删除元素，扩容的时候这个modCount也+1了，看来只要是对共享变量的操作，均做了+1操作。若需要的最小容量大于elementData数组的长度时，才真正会调用grow方法，grow方法是实际进行扩容的方法，往后看grow方法
4、grow（int）方法
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（int minCapacity）接受一个minCapacity，假定传入的minCapacity为11，首先计算现有elementData的长度（假定为10），记录在oldCapacity变量下，根据oldCapacity计算出一个新值newCapacity = 10 + （10 >> 1），则newCapacity = 10 + 5，马上用新的容量减去最小容量，若满足不了要求，就再直接采用minCapacity的值，要是新的容量超过MAX_ARRAY_SIZE，则再次调用hugeCapacity（minCapacity），返回值作为newCapacity的值，最后执行Arrays.copyOf方法，该方法经过层层调用，会创建一个新的按照newCapacity为容量的数组对象，并且把原数组中的元素，逐个复制到新数组中（里面还是靠System.arraycopy方法），新的数组对象会再赋值给elementData，完成扩容行为。旧的数组对象，则因为没有强引用，会被GC自动回收掉！
ArrayList三个迭代器的实现类（在ArrayList中定义的内部类）回顾
1、迭代器实现类Itr
2、迭代器实现类ListItr
3、分割器迭代器ArrayListSpliterator
请暂时忽略SubList
遍历ArrayList元素的三种常用方法
1、通过下标
2、通过迭代器
3、通过for-each
217
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
