1. ArrayList 简介

ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。

ArrayList继承于 **AbstractList** ，实现了 **List**, **RandomAccess**, **Cloneable**, **java.io.Serializable** 这些接口。

  2. public class ArrayList<E> extends AbstractList<E>
  3.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
  5.   }
  • 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 区别?

  1. 是否保证线程安全： ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；
  2. 底层数据结构： Arraylist 底层使用的是 **Object** 数组；LinkedList 底层使用的是 双向链表 数据结构（JDK1.6 之前为循环链表，JDK1.7 取消了循环。注意双向链表和双向循环链表的区别，下面有介绍到！）
  3. 插入和删除是否受元素位置的影响： ① **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))**因为需要先移动到指定位置再插入。
  4. 是否支持快速随机访问： LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。
  5. 内存空间占用： ArrayList 的空 间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间（因为要存放直接后继和直接前驱以及数据）。

2. ArrayList 核心源码解读

  1. package java.util;
  3. import java.util.function.Consumer;
  4. import java.util.function.Predicate;
  5. import java.util.function.UnaryOperator;
  8. public class ArrayList<E> extends AbstractList<E>
  9.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  10. {
  11.     private static final long serialVersionUID = 8683452581122892189L;
  13.     /**
  14.      * 默认初始容量大小
  15.      */
  16.     private static final int DEFAULT_CAPACITY = 10;
  18.     /**
  19.      * 空数组（用于空实例）。
  20.      */
  21.     private static final Object[] EMPTY_ELEMENTDATA = {};
  23.      //用于默认大小空实例的共享空数组实例。
  24.       //我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少。
  25.     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  27.     /**
  28.      * 保存ArrayList数据的数组
  29.      */
  30.     transient Object[] elementData; // non-private to simplify nested class access
  32.     /**
  33.      * ArrayList 所包含的元素个数
  34.      */
  35.     private int size;
  37.     /**
  38.      * 带初始容量参数的构造函数（用户可以在创建ArrayList对象时自己指定集合的初始大小）
  39.      */
  40.     public ArrayList(int initialCapacity) {
  41.         if (initialCapacity > 0) {
  42.             //如果传入的参数大于0，创建initialCapacity大小的数组
  43.             this.elementData = new Object[initialCapacity];
  44.         } else if (initialCapacity == 0) {
  45.             //如果传入的参数等于0，创建空数组
  46.             this.elementData = EMPTY_ELEMENTDATA;
  47.         } else {
  48.             //其他情况，抛出异常
  49.             throw new IllegalArgumentException("Illegal Capacity: "+
  50.                                                initialCapacity);
  51.         }
  52.     }
  54.     /**
  55.      *默认无参构造函数
  56.      *DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为0.初始化为10，也就是说初始其实是空数组 当添加第一个元素的时候数组容量才变成10
  57.      */
  58.     public ArrayList() {
  59.         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  60.     }
  62.     /**
  63.      * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
  64.      */
  65.     public ArrayList(Collection<? extends E> c) {
  66.         //将指定集合转换为数组
  67.         elementData = c.toArray();
  68.         //如果elementData数组的长度不为0
  69.         if ((size = elementData.length) != 0) {
  70.             // 如果elementData不是Object类型数据（c.toArray可能返回的不是Object类型的数组所以加上下面的语句用于判断）
  71.             if (elementData.getClass() != Object[].class)
  72.                 //将原来不是Object类型的elementData数组的内容，赋值给新的Object类型的elementData数组
  73.                 elementData = Arrays.copyOf(elementData, size, Object[].class);
  74.         } else {
  75.             // 其他情况，用空数组代替
  76.             this.elementData = EMPTY_ELEMENTDATA;
  77.         }
  78.     }
  80.     /**
  81.      * 修改这个ArrayList实例的容量是列表的当前大小。 应用程序可以使用此操作来最小化ArrayList实例的存储。
  82.      */
  83.     public void trimToSize() {
  84.         modCount++;
  85.         if (size < elementData.length) {
  86.             elementData = (size == 0)
  87.               ? EMPTY_ELEMENTDATA
  88.               : Arrays.copyOf(elementData, size);
  89.         }
  90.     }
  91. //下面是ArrayList的扩容机制
  92. //ArrayList的扩容机制提高了性能，如果每次只扩充一个，
  93. //那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。
  94.     /**
  95.      * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
  96.      * @param   minCapacity   所需的最小容量
  97.      */
  98.     public void ensureCapacity(int minCapacity) {
  99.         //如果是true，minExpand的值为0，如果是false,minExpand的值为10
  100.         int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
  101.             // any size if not default element table
  102.             ? 0
  103.             // larger than default for default empty table. It's already
  104.             // supposed to be at default size.
  105.             : DEFAULT_CAPACITY;
  106.         //如果最小容量大于已有的最大容量
  107.         if (minCapacity > minExpand) {
  108.             ensureExplicitCapacity(minCapacity);
  109.         }
  110.     }
  111.    //得到最小扩容量
  112.     private void ensureCapacityInternal(int minCapacity) {
  113.         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
  114.               // 获取“默认的容量”和“传入参数”两者之间的最大值
  115.             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
  116.         }
  118.         ensureExplicitCapacity(minCapacity);
  119.     }
  120.   //判断是否需要扩容
  121.     private void ensureExplicitCapacity(int minCapacity) {
  122.         modCount++;
  124.         // overflow-conscious code
  125.         if (minCapacity - elementData.length > 0)
  126.             //调用grow方法进行扩容，调用此方法代表已经开始扩容了
  127.             grow(minCapacity);
  128.     }
  130.     /**
  131.      * 要分配的最大数组大小
  132.      */
  133.     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
  135.     /**
  136.      * ArrayList扩容的核心方法。
  137.      */
  138.     private void grow(int minCapacity) {
  139.         // oldCapacity为旧容量，newCapacity为新容量
  140.         int oldCapacity = elementData.length;
  141.         //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
  142.         //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
  143.         int newCapacity = oldCapacity + (oldCapacity >> 1);
  144.         //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
  145.         if (newCapacity - minCapacity < 0)
  146.             newCapacity = minCapacity;
  147.         //再检查新容量是否超出了ArrayList所定义的最大容量，
  148.         //若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
  149.         //如果minCapacity大于MAX_ARRAY_SIZE，则新容量则为Interger.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE。
  150.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  151.             newCapacity = hugeCapacity(minCapacity);
  152.         // minCapacity is usually close to size, so this is a win:
  153.         elementData = Arrays.copyOf(elementData, newCapacity);
  154.     }
  155.     //比较minCapacity和 MAX_ARRAY_SIZE
  156.     private static int hugeCapacity(int minCapacity) {
  157.         if (minCapacity < 0) // overflow
  158.             throw new OutOfMemoryError();
  159.         return (minCapacity > MAX_ARRAY_SIZE) ?
  160.             Integer.MAX_VALUE :
  161.             MAX_ARRAY_SIZE;
  162.     }
  164.     /**
  165.      *返回此列表中的元素数。
  166.      */
  167.     public int size() {
  168.         return size;
  169.     }
  171.     /**
  172.      * 如果此列表不包含元素，则返回 true 。
  173.      */
  174.     public boolean isEmpty() {
  175.         //注意=和==的区别
  176.         return size == 0;
  177.     }
  179.     /**
  180.      * 如果此列表包含指定的元素，则返回true 。
  181.      */
  182.     public boolean contains(Object o) {
  183.         //indexOf()方法：返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1
  184.         return indexOf(o) >= 0;
  185.     }
  187.     /**
  188.      *返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1
  189.      */
  190.     public int indexOf(Object o) {
  191.         if (o == null) {
  192.             for (int i = 0; i < size; i++)
  193.                 if (elementData[i]==null)
  194.                     return i;
  195.         } else {
  196.             for (int i = 0; i < size; i++)
  197.                 //equals()方法比较
  198.                 if (o.equals(elementData[i]))
  199.                     return i;
  200.         }
  201.         return -1;
  202.     }
  204.     /**
  205.      * 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。.
  206.      */
  207.     public int lastIndexOf(Object o) {
  208.         if (o == null) {
  209.             for (int i = size-1; i >= 0; i--)
  210.                 if (elementData[i]==null)
  211.                     return i;
  212.         } else {
  213.             for (int i = size-1; i >= 0; i--)
  214.                 if (o.equals(elementData[i]))
  215.                     return i;
  216.         }
  217.         return -1;
  218.     }
  220.     /**
  221.      * 返回此ArrayList实例的浅拷贝。 （元素本身不被复制。）
  222.      */
  223.     public Object clone() {
  224.         try {
  225.             ArrayList<?> v = (ArrayList<?>) super.clone();
  226.             //Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度
  227.             v.elementData = Arrays.copyOf(elementData, size);
  228.             v.modCount = 0;
  229.             return v;
  230.         } catch (CloneNotSupportedException e) {
  231.             // 这不应该发生，因为我们是可以克隆的
  232.             throw new InternalError(e);
  233.         }
  234.     }
  236.     /**
  237.      *以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
  238.      *返回的数组将是“安全的”，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。
  239.      *因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。
  240.      */
  241.     public Object[] toArray() {
  242.         return Arrays.copyOf(elementData, size);
  243.     }
  245.     /**
  246.      * 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）;
  247.      *返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。
  248.      *否则，将为指定数组的运行时类型和此列表的大小分配一个新数组。
  249.      *如果列表适用于指定的数组，其余空间（即数组的列表数量多于此元素），则紧跟在集合结束后的数组中的元素设置为null 。
  250.      *（这仅在调用者知道列表不包含任何空元素的情况下才能确定列表的长度。）
  251.      */
  252.     @SuppressWarnings("unchecked")
  253.     public <T> T[] toArray(T[] a) {
  254.         if (a.length < size)
  255.             // 新建一个运行时类型的数组，但是ArrayList数组的内容
  256.             return (T[]) Arrays.copyOf(elementData, size, a.getClass());
  257.             //调用System提供的arraycopy()方法实现数组之间的复制
  258.         System.arraycopy(elementData, 0, a, 0, size);
  259.         if (a.length > size)
  260.             a[size] = null;
  261.         return a;
  262.     }
  264.     // Positional Access Operations
  266.     @SuppressWarnings("unchecked")
  267.     E elementData(int index) {
  268.         return (E) elementData[index];
  269.     }
  271.     /**
  272.      * 返回此列表中指定位置的元素。
  273.      */
  274.     public E get(int index) {
  275.         rangeCheck(index);
  277.         return elementData(index);
  278.     }
  280.     /**
  281.      * 用指定的元素替换此列表中指定位置的元素。
  282.      */
  283.     public E set(int index, E element) {
  284.         //对index进行界限检查
  285.         rangeCheck(index);
  287.         E oldValue = elementData(index);
  288.         elementData[index] = element;
  289.         //返回原来在这个位置的元素
  290.         return oldValue;
  291.     }
  293.     /**
  294.      * 将指定的元素追加到此列表的末尾。
  295.      */
  296.     public boolean add(E e) {
  297.         ensureCapacityInternal(size + 1);  // Increments modCount!!
  298.         //这里看到ArrayList添加元素的实质就相当于为数组赋值
  299.         elementData[size++] = e;
  300.         return true;
  301.     }
  303.     /**
  304.      * 在此列表中的指定位置插入指定的元素。
  305.      *先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
  306.      *再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
  307.      */
  308.     public void add(int index, E element) {
  309.         rangeCheckForAdd(index);
  311.         ensureCapacityInternal(size + 1);  // Increments modCount!!
  312.         //arraycopy()这个实现数组之间复制的方法一定要看一下，下面就用到了arraycopy()方法实现数组自己复制自己
  313.         System.arraycopy(elementData, index, elementData, index + 1,
  314.                          size - index);
  315.         elementData[index] = element;
  316.         size++;
  317.     }
  319.     /**
  320.      * 删除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。
  321.      */
  322.     public E remove(int index) {
  323.         rangeCheck(index);
  325.         modCount++;
  326.         E oldValue = elementData(index);
  328.         int numMoved = size - index - 1;
  329.         if (numMoved > 0)
  330.             System.arraycopy(elementData, index+1, elementData, index,
  331.                              numMoved);
  332.         elementData[--size] = null; // clear to let GC do its work
  333.       //从列表中删除的元素
  334.         return oldValue;
  335.     }
  337.     /**
  338.      * 从列表中删除指定元素的第一个出现（如果存在）。 如果列表不包含该元素，则它不会更改。
  339.      *返回true，如果此列表包含指定的元素
  340.      */
  341.     public boolean remove(Object o) {
  342.         if (o == null) {
  343.             for (int index = 0; index < size; index++)
  344.                 if (elementData[index] == null) {
  345.                     fastRemove(index);
  346.                     return true;
  347.                 }
  348.         } else {
  349.             for (int index = 0; index < size; index++)
  350.                 if (o.equals(elementData[index])) {
  351.                     fastRemove(index);
  352.                     return true;
  353.                 }
  354.         }
  355.         return false;
  356.     }
  358.     /*
  359.      * Private remove method that skips bounds checking and does not
  360.      * return the value removed.
  361.      */
  362.     private void fastRemove(int index) {
  363.         modCount++;
  364.         int numMoved = size - index - 1;
  365.         if (numMoved > 0)
  366.             System.arraycopy(elementData, index+1, elementData, index,
  367.                              numMoved);
  368.         elementData[--size] = null; // clear to let GC do its work
  369.     }
  371.     /**
  372.      * 从列表中删除所有元素。
  373.      */
  374.     public void clear() {
  375.         modCount++;
  377.         // 把数组中所有的元素的值设为null
  378.         for (int i = 0; i < size; i++)
  379.             elementData[i] = null;
  381.         size = 0;
  382.     }
  384.     /**
  385.      * 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
  386.      */
  387.     public boolean addAll(Collection<? extends E> c) {
  388.         Object[] a = c.toArray();
  389.         int numNew = a.length;
  390.         ensureCapacityInternal(size + numNew);  // Increments modCount
  391.         System.arraycopy(a, 0, elementData, size, numNew);
  392.         size += numNew;
  393.         return numNew != 0;
  394.     }
  396.     /**
  397.      * 将指定集合中的所有元素插入到此列表中，从指定的位置开始。
  398.      */
  399.     public boolean addAll(int index, Collection<? extends E> c) {
  400.         rangeCheckForAdd(index);
  402.         Object[] a = c.toArray();
  403.         int numNew = a.length;
  404.         ensureCapacityInternal(size + numNew);  // Increments modCount
  406.         int numMoved = size - index;
  407.         if (numMoved > 0)
  408.             System.arraycopy(elementData, index, elementData, index + numNew,
  409.                              numMoved);
  411.         System.arraycopy(a, 0, elementData, index, numNew);
  412.         size += numNew;
  413.         return numNew != 0;
  414.     }
  416.     /**
  417.      * 从此列表中删除所有索引为fromIndex （含）和toIndex之间的元素。
  418.      *将任何后续元素移动到左侧（减少其索引）。
  419.      */
  420.     protected void removeRange(int fromIndex, int toIndex) {
  421.         modCount++;
  422.         int numMoved = size - toIndex;
  423.         System.arraycopy(elementData, toIndex, elementData, fromIndex,
  424.                          numMoved);
  426.         // clear to let GC do its work
  427.         int newSize = size - (toIndex-fromIndex);
  428.         for (int i = newSize; i < size; i++) {
  429.             elementData[i] = null;
  430.         }
  431.         size = newSize;
  432.     }
  434.     /**
  435.      * 检查给定的索引是否在范围内。
  436.      */
  437.     private void rangeCheck(int index) {
  438.         if (index >= size)
  439.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  440.     }
  442.     /**
  443.      * add和addAll使用的rangeCheck的一个版本
  444.      */
  445.     private void rangeCheckForAdd(int index) {
  446.         if (index > size || index < 0)
  447.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  448.     }
  450.     /**
  451.      * 返回IndexOutOfBoundsException细节信息
  452.      */
  453.     private String outOfBoundsMsg(int index) {
  454.         return "Index: "+index+", Size: "+size;
  455.     }
  457.     /**
  458.      * 从此列表中删除指定集合中包含的所有元素。
  459.      */
  460.     public boolean removeAll(Collection<?> c) {
  461.         Objects.requireNonNull(c);
  462.         //如果此列表被修改则返回true
  463.         return batchRemove(c, false);
  464.     }
  466.     /**
  467.      * 仅保留此列表中包含在指定集合中的元素。
  468.      *换句话说，从此列表中删除其中不包含在指定集合中的所有元素。
  469.      */
  470.     public boolean retainAll(Collection<?> c) {
  471.         Objects.requireNonNull(c);
  472.         return batchRemove(c, true);
  473.     }
  476.     /**
  477.      * 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
  478.      *指定的索引表示初始调用将返回的第一个元素为next 。 初始调用previous将返回指定索引减1的元素。
  479.      *返回的列表迭代器是fail-fast 。
  480.      */
  481.     public ListIterator<E> listIterator(int index) {
  482.         if (index < 0 || index > size)
  483.             throw new IndexOutOfBoundsException("Index: "+index);
  484.         return new ListItr(index);
  485.     }
  487.     /**
  488.      *返回列表中的列表迭代器（按适当的顺序）。
  489.      *返回的列表迭代器是fail-fast 。
  490.      */
  491.     public ListIterator<E> listIterator() {
  492.         return new ListItr(0);
  493.     }
  495.     /**
  496.      *以正确的顺序返回该列表中的元素的迭代器。
  497.      *返回的迭代器是fail-fast 。
  498.      */
  499.     public Iterator<E> iterator() {
  500.         return new Itr();
  501.     }

3. ArrayList 扩容机制分析

3.1. 先从 ArrayList 的构造函数说起

（JDK8）ArrayList 有三种方式来初始化，构造方法源码如下：

  1.    /**
  2.      * 默认初始容量大小
  3.      */
  4.     private static final int DEFAULT_CAPACITY = 10;
  7.     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  9.     /**
  10.      *默认构造函数，使用初始容量10构造一个空列表(无参数构造)
  11.      */
  12.     public ArrayList() {
  13.         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  14.     }
  16.     /**
  17.      * 带初始容量参数的构造函数。（用户自己指定容量）
  18.      */
  19.     public ArrayList(int initialCapacity) {
  20.         if (initialCapacity > 0) {//初始容量大于0
  21.             //创建initialCapacity大小的数组
  22.             this.elementData = new Object[initialCapacity];
  23.         } else if (initialCapacity == 0) {//初始容量等于0
  24.             //创建空数组
  25.             this.elementData = EMPTY_ELEMENTDATA;
  26.         } else {//初始容量小于0，抛出异常
  27.             throw new IllegalArgumentException("Illegal Capacity: "+
  28.                                                initialCapacity);
  29.         }
  30.     }
  33.    /**
  34.     *构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
  35.     *如果指定的集合为null，throws NullPointerException。
  36.     */
  37.      public ArrayList(Collection<? extends E> c) {
  38.         elementData = c.toArray();
  39.         if ((size = elementData.length) != 0) {
  40.             // c.toArray might (incorrectly) not return Object[] (see 6260652)
  41.             if (elementData.getClass() != Object[].class)
  42.                 elementData = Arrays.copyOf(elementData, size, Object[].class);
  43.         } else {
  44.             // replace with empty array.
  45.             this.elementData = EMPTY_ELEMENTDATA;
  46.         }
  47.     }

细心的同学一定会发现 ：以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10。 下面在我们分析 ArrayList 扩容时会讲到这一点内容！

补充：JDK7 new无参构造的ArrayList对象时，直接创建了长度是10的Object[]数组elementData 。jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式。JDK8的内存优化也值得我们在平时开发中学习。

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 进第 1 个元素时，minCapacity 为 1，在 Math.max()方法比较后，minCapacity 为 10。

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

3.2.3. ensureExplicitCapacity() 方法

如果调用 ensureCapacityInternal() 方法就一定会进入（执行）这个方法，下面我们来研究一下这个方法的源码！

  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，此时 e lementData.length(容量)在添加第一个元素后扩容成 10 了。此时，minCapacity - elementData.length > 0 不成立，所以不会进入 （执行）grow(minCapacity) 方法。
  • 添加第 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.         if (newCapacity - minCapacity < 0)
  17.             newCapacity = minCapacity;
  18.        // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
  19.        //如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
  20.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  21.             newCapacity = hugeCapacity(minCapacity);
  22.         // minCapacity is usually close to size, so this is a win:
  23.         elementData = Arrays.copyOf(elementData, newCapacity);
  24.     }

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

“>>”（移位运算符）：>>1 右移一位相当于除 2，右移 n 位相当于除以 2 的 n 次方。这里 oldCapacity 明显右移了 1 位所以相当于 oldCapacity /2。对于大数据的 2 进制运算,位移运算符比那些普通运算符的运算要快很多,因为程序仅仅移动一下而已,不去计算,这样提高了效率,节省了资源

我们再来通过例子探究一下**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。
  • 以此类推······

这里补充一点比较重要，但是容易被忽视掉的知识点：

  • java 中的 length属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了 length 这个属性.
  • java 中的 length() 方法是针对字符串说的,如果想看这个字符串的长度则用到 length() 这个方法.
  • java 中的 size() 方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!

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 中大量调用了这两个方法。比如：我们上面讲的扩容操作以及add(int index, E element)、toArray() 等方法中都用到了该方法！

3.3.1. System.arraycopy() 方法

  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.     }
  17. }

结果：

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

3.3.2. Arrays.copyOf()方法

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

个人觉得使用 Arrays.copyOf()方法主要是为了给原有数组扩容，测试代码如下：

  1. public class ArrayscopyOfTest {
  3.     public static void main(String[] args) {
  4.         int[] a = new int[3];
  5.         a[0] = 0;
  6.         a[1] = 1;
  7.         a[2] = 2;
  8.         int[] b = Arrays.copyOf(a, 10);
  9.         System.out.println("b.length"+b.length);
  10.     }
  11. }

结果：

  1. 10

3.3.3. 两者联系和区别

联系：

看两者源代码可以发现 copyOf()内部实际调用了 System.arraycopy() 方法

区别：

arraycopy() 需要目标数组，将原数组拷贝到你自己定义的数组里或者原数组，而且可以选择拷贝的起点和长度以及放入新数组中的位置 copyOf() 是系统自动在内部新建一个数组，并返回该数组。

3.4. ensureCapacity方法

ArrayList 源码中有一个 ensureCapacity 方法不知道大家注意到没有，这个方法 ArrayList 内部没有被调用过，所以很显然是提供给用户调用的，那么这个方法有什么作用呢？

  1.     /**
  2.     如有必要，增加此 ArrayList 实例的容量，以确保它至少可以容纳由minimum capacity参数指定的元素数。
  3.      *
  4.      * @param   minCapacity   所需的最小容量
  5.      */
  6.     public void ensureCapacity(int minCapacity) {
  7.         int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
  8.             // any size if not default element table
  9.             ? 0
  10.             // larger than default for default empty table. It's already
  11.             // supposed to be at default size.
  12.             : DEFAULT_CAPACITY;
  14.         if (minCapacity > minExpand) {
  15.             ensureExplicitCapacity(minCapacity);
  16.         }
  17.     }

最好在 add 大量元素之前用 **ensureCapacity** 方法，以减少增量重新分配的次数

我们通过下面的代码实际测试以下这个方法的效果：

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

运行结果：

  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 方法，以减少增量重新分配的次数。

我测试的时候发现并没有变快啊，还变慢了不少。