1. ArrayList简介

ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元 素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。
ArrayList 继承于 AbstractList，实现了 List、RandomAccess、Cloneable、java.io.Serializable 这些接口。

  1. public class ArrayList<E> extends AbstractList<E>
  2.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
  4.   }
  • RandomAccess 是一个标志接口，表明实现这个这个接口的 List 集合是支持快速随机访问的。在 ArrayList 中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。
  • ArrayList 实现了 Cloneable 接口 ，即覆盖了函数clone()，能被克隆。
  • ArrayList 实现了 java.io.Serializable 接口，这意味着ArrayList支持序列化，能通过序列化去传输。

    1.1 ArrayList和Vector的区别？

  1. ArrayList 是 List 的主要实现类，底层使用 Object[ ]存储，适用于频繁的查找工作，线程不安全 ；

  2. Vector 是 List 的古老实现类，底层使用 Object[ ]存储，线程安全的。

    1.2 ArrayList与LinkedList的区别？

  3. 是否保证线程安全：ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；

  4. 底层数据结构：Arraylist 底层使用的是 Object 数组；LinkedList 底层使用的是 双向链表 数据结构（JDK1.6 之前为循环链表，JDK1.7 取消了循环。注意双向链表和双向循环链表的区别。）
  5. 插入和删除是否受元素位置的影响：

① ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。 比如：执行add(E e)方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话add(int index, E element)时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。
② LinkedList 采用链表存储，所以对于add(E e)方法的插入，删除元素时间复杂度不受元素位置的影响，近似 O(1)，如果是要在指定位置 **i** 插入和删除元素的话(**add(int index, E element)**)，时间复杂度近似为**o(n)**因为需要先移动到指定位置再插入。

  1. 是否支持快速随机访问： LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。
  2. 内存空间占用： ArrayList 的空间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间（因为要存放直接后继和直接前驱以及数据）。

    2. ArrayList核心源码解读

    ```java package java.util;

import java.util.function.Consumer; import java.util.function.Predicate; import java.util.function.UnaryOperator;

public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable { private static final long serialVersionUID = 8683452581122892189L;

  1. /**
  2.  * 默认初始容量大小
  3.  */
  4. private static final int DEFAULT_CAPACITY = 10;
  6. /**
  7.  * 空数组（用于空实例）。
  8.  */
  9. private static final Object[] EMPTY_ELEMENTDATA = {};
  11. //用于默认大小空实例的共享空数组实例。
  12. //我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少。
  13. private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  15. /**
  16.  * 保存ArrayList数据的数组, transient关键字使得elementData无法序列化
  17.  */
  18. transient Object[] elementData; // non-private to simplify nested class access
  20. /**
  21.  * ArrayList 所包含的元素个数
  22.  */
  23. private int size;
  25. /**
  26.  * 带初始容量参数的构造函数（用户可以在创建ArrayList对象时自己指定集合的初始大小）
  27.  */
  28. public ArrayList(int initialCapacity) {
  29.     if (initialCapacity > 0) {
  30.         //如果传入的参数大于0，创建initialCapacity大小的数组
  31.         this.elementData = new Object[initialCapacity];
  32.     } else if (initialCapacity == 0) {
  33.         //如果传入的参数等于0，创建空数组
  34.         this.elementData = EMPTY_ELEMENTDATA;
  35.     } else {
  36.         //其他情况，抛出异常
  37.         throw new IllegalArgumentException("Illegal Capacity: "+
  38.                                            initialCapacity);
  39.     }
  40. }
  42. /**
  43.  *默认无参构造函数
  44.  *DEFAULTCAPACITY_EMPTY_ELEMENTDATA为0.初始化为10，也就是说初始其实是空数组。
  45.  *当添加第一个元素的时候数组容量才变成10
  46.  */
  47. public ArrayList() {
  48.     this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  49. }
  51. /**
  52.  * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
  53.  */
  54. public ArrayList(Collection<? extends E> c) {
  55.     //将指定集合转换为数组
  56.     elementData = c.toArray();
  57.     //如果elementData数组的长度不为0
  58.     if ((size = elementData.length) != 0) {
  59.         // 如果elementData不是Object类型数据（c.toArray可能返回的不是Object类型的数组所以加上下面的语句用于判断）
  60.         if (elementData.getClass() != Object[].class)
  61.             //将原来不是Object类型的elementData数组的内容，赋值给新的Object类型的elementData数组
  62.             elementData = Arrays.copyOf(elementData, size, Object[].class);
  63.     } else {
  64.         // 其他情况，用空数组代替
  65.         this.elementData = EMPTY_ELEMENTDATA;
  66.     }
  67. }
  69. /**
  70.  * 修改这个ArrayList实例的容量是列表的当前大小。 应用程序可以使用此操作来最小化ArrayList实例的存储。
  71.  */
  72. public void trimToSize() {
  73.     modCount++;
  74.     if (size < elementData.length) {
  75.         elementData = (size == 0)
  76.           ? EMPTY_ELEMENTDATA
  77.           : Arrays.copyOf(elementData, size);
  78.     }
  79. }
  80. //下面是ArrayList的扩容机制
  81. //ArrayList的扩容机制提高了性能，如果每次只扩充一个，
  82. //那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。
  83. /**
  84.  * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
  85.  * @param   minCapacity   所需的最小容量
  86.  */
  87. public void ensureCapacity(int minCapacity) {
  88.     //如果是true，minExpand的值为0，如果是false,minExpand的值为10
  89.     int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
  90.         // any size if not default element table
  91.         ? 0
  92.         // larger than default for default empty table. It's already
  93.         // supposed to be at default size.
  94.         : DEFAULT_CAPACITY;
  95.     //如果最小容量大于已有的最大容量
  96.     if (minCapacity > minExpand) {
  97.         ensureExplicitCapacity(minCapacity);
  98.     }
  99. }

//得到最小扩容量 private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 获取“默认的容量”和“传入参数”两者之间的最大值 minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); }

  1.     ensureExplicitCapacity(minCapacity);
  2. }

//判断是否需要扩容 private void ensureExplicitCapacity(int minCapacity) { modCount++;

  1.     // overflow-conscious code
  2.     if (minCapacity - elementData.length > 0)
  3.         //调用grow方法进行扩容，调用此方法代表已经开始扩容了
  4.         grow(minCapacity);
  5. }
  7. /**
  8.  * 要分配的最大数组大小
  9.  */
  10. private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
  12. /**
  13.  * ArrayList扩容的核心方法。
  14.  */
  15. private void grow(int minCapacity) {
  16.     // oldCapacity为旧容量，newCapacity为新容量
  17.     int oldCapacity = elementData.length;
  18.     //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
  19.     //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
  20.     int newCapacity = oldCapacity + (oldCapacity >> 1);
  21.     //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
  22.     if (newCapacity - minCapacity < 0)
  23.         newCapacity = minCapacity;
  24.     //再检查新容量是否超出了ArrayList所定义的最大容量，
  25.     //若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
  26.     //如果minCapacity大于MAX_ARRAY_SIZE，则新容量则为Interger.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE。
  27.     if (newCapacity - MAX_ARRAY_SIZE > 0)
  28.         newCapacity = hugeCapacity(minCapacity);
  29.     // minCapacity is usually close to size, so this is a win:
  30.     elementData = Arrays.copyOf(elementData, newCapacity);
  31. }
  32. //比较minCapacity和 MAX_ARRAY_SIZE
  33. private static int hugeCapacity(int minCapacity) {
  34.     if (minCapacity < 0) // overflow
  35.         throw new OutOfMemoryError();
  36.     return (minCapacity > MAX_ARRAY_SIZE) ?
  37.         Integer.MAX_VALUE :
  38.         MAX_ARRAY_SIZE;
  39. }
  41. /**
  42.  *返回此列表中的元素数。
  43.  */
  44. public int size() {
  45.     return size;
  46. }
  48. /**
  49.  * 如果此列表不包含元素，则返回 true 。
  50.  */
  51. public boolean isEmpty() {
  52.     //注意=和==的区别
  53.     return size == 0;
  54. }
  56. /**
  57.  * 如果此列表包含指定的元素，则返回true 。
  58.  */
  59. public boolean contains(Object o) {
  60.     //indexOf()方法：返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1
  61.     return indexOf(o) >= 0;
  62. }
  64. /**
  65.  *返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1
  66.  */
  67. public int indexOf(Object o) {
  68.     if (o == null) {
  69.         for (int i = 0; i < size; i++)
  70.             if (elementData[i]==null)
  71.                 return i;
  72.     } else {
  73.         for (int i = 0; i < size; i++)
  74.             //equals()方法比较
  75.             if (o.equals(elementData[i]))
  76.                 return i;
  77.     }
  78.     return -1;
  79. }
  81. /**
  82.  * 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。.
  83.  */
  84. public int lastIndexOf(Object o) {
  85.     if (o == null) {
  86.         for (int i = size-1; i >= 0; i--)
  87.             if (elementData[i]==null)
  88.                 return i;
  89.     } else {
  90.         for (int i = size-1; i >= 0; i--)
  91.             if (o.equals(elementData[i]))
  92.                 return i;
  93.     }
  94.     return -1;
  95. }
  97. /**
  98.  * 返回此ArrayList实例的浅拷贝。 （元素本身不被复制。）
  99.  */
  100. public Object clone() {
  101.     try {
  102.         ArrayList<?> v = (ArrayList<?>) super.clone();
  103.         //Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度
  104.         v.elementData = Arrays.copyOf(elementData, size);
  105.         v.modCount = 0;
  106.         return v;
  107.     } catch (CloneNotSupportedException e) {
  108.         // 这不应该发生，因为我们是可以克隆的
  109.         throw new InternalError(e);
  110.     }
  111. }
  113. /**
  114.  *以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
  115.  *返回的数组将是“安全的”，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。
  116.  *因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。
  117.  */
  118. public Object[] toArray() {
  119.     return Arrays.copyOf(elementData, size);
  120. }
  122. /**
  123.  * 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）;
  124.  *返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。
  125.  *否则，将为指定数组的运行时类型和此列表的大小分配一个新数组。
  126.  *如果列表适用于指定的数组，其余空间（即数组的列表数量多于此元素），则紧跟在集合结束后的数组中的元素设置为null 。
  127.  *（这仅在调用者知道列表不包含任何空元素的情况下才能确定列表的长度。）
  128.  */
  129. @SuppressWarnings("unchecked")
  130. public <T> T[] toArray(T[] a) {
  131.     if (a.length < size)
  132.         // 新建一个运行时类型的数组，但是ArrayList数组的内容
  133.         return (T[]) Arrays.copyOf(elementData, size, a.getClass());
  134.         //调用System提供的arraycopy()方法实现数组之间的复制
  135.     System.arraycopy(elementData, 0, a, 0, size);
  136.     if (a.length > size)
  137.         a[size] = null;
  138.     return a;
  139. }
  141. // Positional Access Operations
  143. @SuppressWarnings("unchecked")
  144. E elementData(int index) {
  145.     return (E) elementData[index];
  146. }
  148. /**
  149.  * 返回此列表中指定位置的元素。
  150.  */
  151. public E get(int index) {
  152.     rangeCheck(index);
  154.     return elementData(index);
  155. }
  157. /**
  158.  * 用指定的元素替换此列表中指定位置的元素。
  159.  */
  160. public E set(int index, E element) {
  161.     //对index进行界限检查
  162.     rangeCheck(index);
  164.     E oldValue = elementData(index);
  165.     elementData[index] = element;
  166.     //返回原来在这个位置的元素
  167.     return oldValue;
  168. }
  170. /**
  171.  * 将指定的元素追加到此列表的末尾。
  172.  */
  173. public boolean add(E e) {
  174.     ensureCapacityInternal(size + 1);  // Increments modCount!!
  175.     //这里看到ArrayList添加元素的实质就相当于为数组赋值
  176.     elementData[size++] = e;
  177.     return true;
  178. }
  180. /**
  181.  * 在此列表中的指定位置插入指定的元素。
  182.  *先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
  183.  *再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
  184.  */
  185. public void add(int index, E element) {
  186.     rangeCheckForAdd(index);
  188.     ensureCapacityInternal(size + 1);  // Increments modCount!!
  189.     //arraycopy()这个实现数组之间复制的方法一定要看一下，下面就用到了arraycopy()方法实现数组自己复制自己
  190.     System.arraycopy(elementData, index, elementData, index + 1,
  191.                      size - index);
  192.     elementData[index] = element;
  193.     size++;
  194. }
  196. /**
  197.  * 删除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。
  198.  */
  199. public E remove(int index) {
  200.     rangeCheck(index);
  202.     modCount++;
  203.     E oldValue = elementData(index);
  205.     int numMoved = size - index - 1;
  206.     if (numMoved > 0)
  207.         System.arraycopy(elementData, index+1, elementData, index,
  208.                          numMoved);
  209.     elementData[--size] = null; // clear to let GC do its work
  210.   //从列表中删除的元素
  211.     return oldValue;
  212. }
  214. /**
  215.  * 从列表中删除指定元素的第一个出现（如果存在）。 如果列表不包含该元素，则它不会更改。
  216.  *返回true，如果此列表包含指定的元素
  217.  */
  218. public boolean remove(Object o) {
  219.     if (o == null) {
  220.         for (int index = 0; index < size; index++)
  221.             if (elementData[index] == null) {
  222.                 fastRemove(index);
  223.                 return true;
  224.             }
  225.     } else {
  226.         for (int index = 0; index < size; index++)
  227.             if (o.equals(elementData[index])) {
  228.                 fastRemove(index);
  229.                 return true;
  230.             }
  231.     }
  232.     return false;
  233. }
  235. /*
  236.  * Private remove method that skips bounds checking and does not
  237.  * return the value removed.
  238.  */
  239. private void fastRemove(int index) {
  240.     modCount++;
  241.     int numMoved = size - index - 1;
  242.     if (numMoved > 0)
  243.         System.arraycopy(elementData, index+1, elementData, index,
  244.                          numMoved);
  245.     elementData[--size] = null; // clear to let GC do its work
  246. }
  248. /**
  249.  * 从列表中删除所有元素。
  250.  */
  251. public void clear() {
  252.     modCount++;
  254.     // 把数组中所有的元素的值设为null
  255.     for (int i = 0; i < size; i++)
  256.         elementData[i] = null;
  258.     size = 0;
  259. }
  261. /**
  262.  * 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
  263.  */
  264. public boolean addAll(Collection<? extends E> c) {
  265.     Object[] a = c.toArray();
  266.     int numNew = a.length;
  267.     ensureCapacityInternal(size + numNew);  // Increments modCount
  268.     System.arraycopy(a, 0, elementData, size, numNew);
  269.     size += numNew;
  270.     return numNew != 0;
  271. }
  273. /**
  274.  * 将指定集合中的所有元素插入到此列表中，从指定的位置开始。
  275.  */
  276. public boolean addAll(int index, Collection<? extends E> c) {
  277.     rangeCheckForAdd(index);
  279.     Object[] a = c.toArray();
  280.     int numNew = a.length;
  281.     ensureCapacityInternal(size + numNew);  // Increments modCount
  283.     int numMoved = size - index;
  284.     if (numMoved > 0)
  285.         System.arraycopy(elementData, index, elementData, index + numNew,
  286.                          numMoved);
  288.     System.arraycopy(a, 0, elementData, index, numNew);
  289.     size += numNew;
  290.     return numNew != 0;
  291. }
  293. /**
  294.  * 从此列表中删除所有索引为fromIndex （含）和toIndex之间的元素。
  295.  *将任何后续元素移动到左侧（减少其索引）。
  296.  */
  297. protected void removeRange(int fromIndex, int toIndex) {
  298.     modCount++;
  299.     int numMoved = size - toIndex;
  300.     System.arraycopy(elementData, toIndex, elementData, fromIndex,
  301.                      numMoved);
  303.     // clear to let GC do its work
  304.     int newSize = size - (toIndex-fromIndex);
  305.     for (int i = newSize; i < size; i++) {
  306.         elementData[i] = null;
  307.     }
  308.     size = newSize;
  309. }
  311. /**
  312.  * 检查给定的索引是否在范围内。
  313.  */
  314. private void rangeCheck(int index) {
  315.     if (index >= size)
  316.         throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  317. }
  319. /**
  320.  * add和addAll使用的rangeCheck的一个版本
  321.  */
  322. private void rangeCheckForAdd(int index) {
  323.     if (index > size || index < 0)
  324.         throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  325. }
  327. /**
  328.  * 返回IndexOutOfBoundsException细节信息
  329.  */
  330. private String outOfBoundsMsg(int index) {
  331.     return "Index: "+index+", Size: "+size;
  332. }
  334. /**
  335.  * 从此列表中删除指定集合中包含的所有元素。
  336.  */
  337. public boolean removeAll(Collection<?> c) {
  338.     Objects.requireNonNull(c);
  339.     //如果此列表被修改则返回true
  340.     return batchRemove(c, false);
  341. }
  343. /**
  344.  * 仅保留此列表中包含在指定集合中的元素。
  345.  *换句话说，从此列表中删除其中不包含在指定集合中的所有元素。
  346.  */
  347. public boolean retainAll(Collection<?> c) {
  348.     Objects.requireNonNull(c);
  349.     return batchRemove(c, true);
  350. }
  353. /**
  354.  * 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
  355.  *指定的索引表示初始调用将返回的第一个元素为next 。 初始调用previous将返回指定索引减1的元素。
  356.  *返回的列表迭代器是fail-fast 。
  357.  */
  358. public ListIterator<E> listIterator(int index) {
  359.     if (index < 0 || index > size)
  360.         throw new IndexOutOfBoundsException("Index: "+index);
  361.     return new ListItr(index);
  362. }
  364. /**
  365.  *返回列表中的列表迭代器（按适当的顺序）。
  366.  *返回的列表迭代器是fail-fast 。
  367.  */
  368. public ListIterator<E> listIterator() {
  369.     return new ListItr(0);
  370. }
  372. /**
  373.  *以正确的顺序返回该列表中的元素的迭代器。
  374.  *返回的迭代器是fail-fast 。
  375.  */
  376. public Iterator<E> iterator() {
  377.     return new Itr();
  378. }

}

  1. <a name="ObpzI"></a>
  2. # 3. ArrayList扩容机制分析
  3. <a name="WCS3B"></a>
  4. ## 3.1 ArrayList的构造函数
  5. **ArrayList(JDK 8)**有三种方式来初始化，构造方法源码如下：
  6. ```java
  7.    /**
  8.      * 默认初始容量大小
  9.      */
  10.     private static final int DEFAULT_CAPACITY = 10;
  13.     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  15.     /**
  16.      *默认构造函数，使用初始容量10构造一个空列表(无参数构造)
  17.      */
  18.     public ArrayList() {
  19.         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  20.     }
  22.     /**
  23.      * 带初始容量参数的构造函数。（用户自己指定容量）
  24.      */
  25.     public ArrayList(int initialCapacity) {
  26.         if (initialCapacity > 0) {//初始容量大于0
  27.             //创建initialCapacity大小的数组
  28.             this.elementData = new Object[initialCapacity];
  29.         } else if (initialCapacity == 0) {//初始容量等于0
  30.             //创建空数组
  31.             this.elementData = EMPTY_ELEMENTDATA;
  32.         } else {//初始容量小于0，抛出异常
  33.             throw new IllegalArgumentException("Illegal Capacity: "+
  34.                                                initialCapacity);
  35.         }
  36.     }
  39.    /**
  40.     *构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
  41.     *如果指定的集合为null，throws NullPointerException。
  42.     */
  43.      public ArrayList(Collection<? extends E> c) {
  44.         elementData = c.toArray();
  45.         if ((size = elementData.length) != 0) {
  46.             // c.toArray might (incorrectly) not return Object[] (see 6260652)
  47.             if (elementData.getClass() != Object[].class)
  48.                 elementData = Arrays.copyOf(elementData, size, Object[].class);
  49.         } else {
  50.             // replace with empty array.
  51.             this.elementData = EMPTY_ELEMENTDATA;
  52.         }
  53.     }

以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为10。

补充：JDK7 new无参构造的ArrayList对象时，直接创建了长度是10的Object[]数组elementData 。jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式。

3.2 ArrayList扩容机制

以无参构造函数创建的 ArrayList 为例分析。

3.2.1 add()方法

  1.     /**
  2.      * 将指定的元素追加到此列表的末尾。
  3.      */
  4.     public boolean add(E e) {
  5.    //添加元素之前，先调用ensureCapacityInternal方法
  6.         ensureCapacityInternal(size + 1);  // Increments modCount!!
  7.         //这里看到ArrayList添加元素的实质就相当于为数组赋值
  8.         elementData[size++] = e;
  9.         return true;
  10.     }

注：JDK11 移除了 **ensureCapacityInternal()** 和 **ensureExplicitCapacity()** 方法

3.2.2 ensureCapacityInternal()方法

（JDK7）可以看到 add 方法 首先调用了ensureCapacityInternal(size + 1)

  1.    //得到最小扩容量
  2.     private void ensureCapacityInternal(int minCapacity) {
  3.         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
  4.               // 获取默认的容量和传入参数的较大值
  5.             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
  6.         }
  8.         ensureExplicitCapacity(minCapacity);
  9.     }

调用**add()**方法添加第一个元素时，minCapacity为1，经过**max()**方法比较后，minCapacity为10。

此处和后续 JDK8 代码格式化略有不同，核心代码基本一样。

3.2.3 ensureExplicitCapacity()方法

  1.   //判断是否需要扩容
  2.     private void ensureExplicitCapacity(int minCapacity) {
  3.         modCount++;
  5.         // overflow-conscious code
  6.         if (minCapacity - elementData.length > 0)
  7.             //调用grow方法进行扩容，调用此方法代表已经开始扩容了
  8.             grow(minCapacity);
  9.     }
  • 当我们要add进第 1 个元素到 ArrayList 时，elementData.length 为 0 （因为还是一个空的 list），因为执行了 ensureCapacityInternal()方法 ，所以 minCapacity 此时为 10。此时，minCapacity - elementData.length > 0成立，所以会进入 grow(minCapacity) 方法。
  • 当 add 第 2 个元素时，minCapacity为 2，此时elementData.length(容量)在添加第一个元素后扩容成 10 了。此时，minCapacity - elementData.length > 0 不成立，所以不会进入(执行)grow()方法。
  • 添加第 3，4，…，10 个元素时，依然不会执行 grow 方法，数组容量都为 10。

直到添加第 11 个元素，minCapacity=11比elementData.length=10要大。进入grow()方法进行扩容。

3.2.4 grow()方法

  1.     /**
  2.      * 要分配的最大数组大小
  3.      */
  4.     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
  6.     /**
  7.      * ArrayList扩容的核心方法。
  8.      */
  9.     private void grow(int minCapacity) {
  10.         // oldCapacity为旧容量，newCapacity为新容量
  11.         int oldCapacity = elementData.length;
  12.         // 将oldCapacity 右移一位，其效果相当于oldCapacity /2，
  13.         // 我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
  14.         int newCapacity = oldCapacity + (oldCapacity >> 1);
  15.         // 然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，
  16.         // 那么就把最小需要容量当作数组的新容量，
  17.         if (newCapacity - minCapacity < 0)
  18.             newCapacity = minCapacity;
  19.         // 如果新容量大于 MAX_ARRAY_SIZE, 进入hugeCapacity()方法来比较 minCapacity 和 MAX_ARRAY_SIZE
  20.         // 如果minCapacity大于最大容量, 则新容量则为Integer.MAX_VALUE，
  21.         // 否则, 新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8。
  22.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  23.             newCapacity = hugeCapacity(minCapacity);
  24.         // minCapacity is usually close to size, so this is a win:
  25.         elementData = Arrays.copyOf(elementData, newCapacity);
  26.     }

扩容方法：**int newCapacity = oldCapacity + (oldCapacity >> 1)**，所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍左右(oldCapacity 为偶数就是 1.5 倍，否则是 1.5 倍左右)！奇偶不同，比如：10+10/2 = 15，33+33/2=49。如果是奇数的话会丢掉小数。
探究grow()方法：

  • 当 add 第 1 个元素时，oldCapacity为 0，经比较后第一个 if 判断成立，newCapacity = minCapacity(为 10)。但是第二个 if 判断不会成立，即 newCapacity 不比 MAX_ARRAY_SIZE 大，则不会进入 hugeCapacity() 方法。数组容量为 10，add 方法中 return true，size 增为 1。
  • 当 add 第 11 个元素进入 grow 方法时，newCapacity 为 15，比 minCapacity(为11)大，第一个 if 判断不成立。新容量没有大于数组最大 size，不会进入 hugeCapacity() 方法。数组容量扩为 15，add方法中 return true，size 增为 11。

  • 以此类推······

    3.2.5 hugeCapacity()方法

    从上面 grow() 方法源码我们知道：如果新容量大于 MAX_ARRAY_SIZE，进入(执行) hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，如果 minCapacity 大于最大容量，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8。

    1.   private static int hugeCapacity(int minCapacity) {
    2.       if (minCapacity < 0) // overflow
    3.           throw new OutOfMemoryError();
    4.       //对minCapacity和MAX_ARRAY_SIZE进行比较
    5.       //若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
    6.       //若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
    7.       //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    8.       return (minCapacity > MAX_ARRAY_SIZE) ?
    9.           Integer.MAX_VALUE :
    10.           MAX_ARRAY_SIZE;
    11.   }

    3.3 System.arraycopy()和Arrays.copyof()方法

    ArrayList 中大量调用了这两个方法来进行拷贝。

    3.3.1 System.arraycopy()方法

    源码：

    1.   // 我们发现 arraycopy 是一个 native 方法,接下来我们解释一下各个参数的具体意义
    2.   /**
    3.   *   复制数组
    4.   * @param src 源数组
    5.   * @param srcPos 源数组中的起始位置
    6.   * @param dest 目标数组
    7.   * @param destPos 目标数组中的起始位置
    8.   * @param length 要复制的数组元素的数量
    9.   */
    10.   public static native void arraycopy(Object src,  int  srcPos,
    11.                                       Object dest, int destPos,
    12.                                       int length);

    场景：

    1.   /**
    2.    * 在此列表中的指定位置插入指定的元素。
    3.    *先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
    4.    *再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
    5.    */
    6.   public void add(int index, E element) {
    7.       rangeCheckForAdd(index);
    9.       ensureCapacityInternal(size + 1);  // Increments modCount!!
    10.       //arraycopy()方法实现数组自己复制自己
    11.       //elementData:源数组;index:源数组中的起始位置;elementData：目标数组；index + 1：目标数组中的起始位置； size - index：要复制的数组元素的数量；
    12.       System.arraycopy(elementData, index, elementData, index + 1, size - index);
    13.       elementData[index] = element;
    14.       size++;
    15.   }

    写一个简单的方法进行测试：

    1. public class ArraycopyTest {
    3.   public static void main(String[] args) {
    4.       // TODO Auto-generated method stub
    5.       int[] a = new int[10];
    6.       a[0] = 0;
    7.       a[1] = 1;
    8.       a[2] = 2;
    9.       a[3] = 3;
    10.       System.arraycopy(a, 2, a, 3, 3);
    11.       a[2]=99;
    12.       for (int i = 0; i < a.length; i++) {
    13.           System.out.print(a[i] + " ");
    14.       }
    15.   }
    16. }

    结果：

    1. 0 1 99 2 3 0 0 0 0 0

    3.3.2 Arrays.copyof()

    源码：

    1.   public static int[] copyOf(int[] original, int newLength) {
    2.       // 申请一个新的数组
    3.       int[] copy = new int[newLength];
    4.       // 调用System.arraycopy,将源数组中的数据进行拷贝,并返回新的数组
    5.       System.arraycopy(original, 0, copy, 0,
    6.                        Math.min(original.length, newLength));
    7.       return copy;
    8.   }

    场景：

    1.  /**
    2.    以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。
    3.    */
    4.   public Object[] toArray() {
    5.   //elementData：要复制的数组；size：要复制的长度
    6.       return Arrays.copyOf(elementData, size);
    7.   }

    3.3.3 两者联系和区别

    联系：
    看两者源代码可以发现 copyOf() 内部实际调用了 System.arraycopy() 方法。
    区别：
    arraycopy() 需要目标数组，将原数组拷贝到你自己定义的数组里或者原数组，而且可以选择拷贝的起点和长度以及放入新数组中的位置 copyOf() 是系统自动在内部新建一个数组，并返回该数组。

    3.4 ensureCapacity方法

    ArrayList源码中有ensureCapacity()方法，在内部没有被调用，主要是提供给用户调用： ```java /* 如有必要，增加此 ArrayList 实例的容量，以确保它至少可以容纳由minimum capacity参数指定的元素数。

    • @param minCapacity 所需的最小容量 */ public void ensureCapacity(int minCapacity) { int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)

      1.  // any size if not default element table
      2.  ? 0
      3.  // larger than default for default empty table. It's already
      4.  // supposed to be at default size.
      5.  : DEFAULT_CAPACITY;

      if (minCapacity > minExpand) {

      1.  ensureExplicitCapacity(minCapacity);

      } }

  1. **最好在 add 大量元素之前用 ensureCapacity 方法，以减少增量重新分配的次数。**
  2. ```java
  3. public class EnsureCapacityTest {
  4.     public static void main(String[] args) {
  5.         ArrayList<Object> list = new ArrayList<Object>();
  6.         final int N = 10000000;
  7.         long startTime = System.currentTimeMillis();
  8.         for (int i = 0; i < N; i++) {
  9.             list.add(i);
  10.         }
  11.         long endTime = System.currentTimeMillis();
  12.         System.out.println("使用ensureCapacity方法前："+(endTime - startTime));
  14.     }
  15. }

运行结果：

  1. 使用ensureCapacity方法前：2158
  1. public class EnsureCapacityTest {
  2.     public static void main(String[] args) {
  3.         ArrayList<Object> list = new ArrayList<Object>();
  4.         final int N = 10000000;
  5.         list = new ArrayList<Object>();
  6.         long startTime1 = System.currentTimeMillis();
  7.         list.ensureCapacity(N);
  8.         for (int i = 0; i < N; i++) {
  9.             list.add(i);
  10.         }
  11.         long endTime1 = System.currentTimeMillis();
  12.         System.out.println("使用ensureCapacity方法后："+(endTime1 - startTime1));
  13.     }
  14. }

运行结果：

  1. 使用ensureCapacity方法后：1773

通过运行结果，我们可以看出向 ArrayList 添加大量元素之前最好先使用 ensureCapacity() 方法，以减少增量重新分配的次数。