ArrayList

概述

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

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

在我们学数据结构的时候就知道了线性表的顺序存储，插入删除元素的时间复杂度为O(n),求表长以及增加元素，取第 i 元素的时间复杂度为O(1)

• ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
• ArrayList 实现了RandomAccess 接口， RandomAccess 是一个标志接口，表明实现这个这个接口的 List 集合是支持快速随机访问的。在 ArrayList 中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。
• ArrayList 实现了Cloneable 接口，即覆盖了函数 clone()，能被克隆。
• ArrayList 实现java.io.Serializable 接口，这意味着ArrayList支持序列化，能通过序列化去传输。
• 和 Vector 不同，ArrayList 中的操作不是线程安全的！所以，建议在单线程中才使用 ArrayList，而在多线程中可以选择 Vector 或者 CopyOnWriteArrayList。

源码分析

构造方法

ArrayList有三个构造方法，相关代码如下：

private static final long serialVersionUID = 8683452581122892189L;

   /**
    * 默认初始容量大小
    */
   private static final int DEFAULT_CAPACITY = 10;

   /**
    * 空数组（用于空实例）。
    */
   private static final Object[] EMPTY_ELEMENTDATA = {};

    //用于默认大小空实例的共享空数组实例。
    //我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少。
   private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

   /**
    * 保存ArrayList数据的数组
    */
   transient Object[] elementData; // non-private to simplify nested class access

   /**
    * ArrayList 所包含的元素个数
    */
   private int size;

   /**
    * 带初始容量参数的构造函数。（用户自己指定容量）
    */
   public ArrayList(int initialCapacity) {
       if (initialCapacity > 0) {
           //创建initialCapacity大小的数组
           this.elementData = new Object[initialCapacity];
       } else if (initialCapacity == 0) {
           //创建空数组
           this.elementData = EMPTY_ELEMENTDATA;
       } else {
           throw new IllegalArgumentException("Illegal Capacity: "+
                                              initialCapacity);
       }
   }

   /**
    *默认构造函数，DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为0.初始化为10，也就是说初始其实是空数组 当添加第一个元素的时候数组容量才变成10
    */
   public ArrayList() {
       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
   }

   /**
    * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
    */
   public ArrayList(Collection<? extends E> c) {
       //
       elementData = c.toArray();
       //如果指定集合元素个数不为0
       if ((size = elementData.length) != 0) {
           // c.toArray 可能返回的不是Object类型的数组所以加上下面的语句用于判断，
           //这里用到了反射里面的getClass()方法
           if (elementData.getClass() != Object[].class)
               elementData = Arrays.copyOf(elementData, size, Object[].class);
       } else {
           // 用空数组代替
           this.elementData = EMPTY_ELEMENTDATA;
       }
   }

上面的代码比较简单，三个构造方法做的事情并不复杂，目的都是初始化底层数组 elementData。

区别在于无参构造方法会将 elementData 初始化一个空数组，插入元素时，扩容将会按默认值重新初始化数组。而有参的构造方法则会将 elementData 初始化为参数值大小（>= 0）的数组。一般情况下，我们用默认的构造方法即可。倘若在可知道将会向 ArrayList 插入多少元素的情况下，应该使用有参构造方法。按需分配，避免浪费。

方法参数为Collection集合的构造参数旨在构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

插入

对于数组（线性表）结构，插入操作分为两种情况。一种是在元素序列尾部插入，另一种是在元素序列其他位置插入。ArrayList 的源码里也体现了这两种插入情况，如下：

/**
    * 将指定的元素追加到此列表的末尾。 
    */
   public boolean add(E e) {
       ensureCapacityInternal(size + 1);  // Increments modCount!!
       //这里看到ArrayList添加元素的实质就相当于为数组赋值
       elementData[size++] = e;
       return true;
   }

   /**
    * 在此列表中的指定位置插入指定的元素。 
    *先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
    *再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
    */
   public void add(int index, E element) {
       rangeCheckForAdd(index);
	//检测是否需要扩容
       ensureCapacityInternal(size + 1);  // Increments modCount!!
       //arraycopy()这个实现数组之间复制的方法一定要看一下，下面就用到了arraycopy()方法实现数组自己复制自己
       System.arraycopy(elementData, index, elementData, index + 1,
                        size - index);
       elementData[index] = element;
       size++;
   }

• 对于在元素序列尾部插入，这种情况比较简单，只需两个步骤即可：

  1. 检测数组是否有足够的空间插入
  2. 将新元素插入至序列尾部

  如下图：

  

• 如果是在元素序列指定位置（假设该位置合理）插入，则情况稍微复杂一点，需要三个步骤：

  1. 检测数组是否有足够的空间
  2. 将 index 及其之后的所有元素向后移一位
  3. 将新元素插入至 index 处

  如下图：

  

总结：从上图可以看出，将新元素插入至序列指定位置，需要先将该位置及其之后的元素都向后移动一位，为新元素腾出位置。这个操作的时间复杂度为O(N)，频繁移动元素可能会导致效率问题，特别是集合中元素数量较多时。在日常开发中，若非所需，我们应当尽量避免在大集合中调用第二个插入方法。

删除

不同于插入操作，ArrayList 没有无参删除方法。所以其只能删除指定位置的元素或删除指定元素，这样就无法避免移动元素（除非从元素序列的尾部删除）。相关代码如下：

/**
    * 删除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。 
    */
   public E remove(int index) {
       rangeCheck(index);

       modCount++;
       E oldValue = 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;
   }

   /**
    * 从列表中删除指定元素的第一个出现（如果存在）。 如果列表不包含该元素，则它不会更改。
    *返回true，如果此列表包含指定的元素
    */
   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;
   }

   /*
    * Private remove method that skips bounds checking and does not
    * return the value removed.
    */
   private void fastRemove(int index) {
       modCount++;
       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
   }

   /**
    * 从列表中删除所有元素。 
    */
   public void clear() {
       modCount++;

       // 把数组中所有的元素的值设为null
       for (int i = 0; i < size; i++)
           elementData[i] = null;

       size = 0;
   }

上面的删除方法并不复杂，这里以第一个删除方法为例，删除一个元素步骤如下：

1. 获取指定位置 index 处的元素值
2. 将 index + 1 及之后的元素向前移动一位
3. 将最后一个元素置空，并将 size 值减 1
4. 返回被删除值，完成删除操作

如下图：

现在，考虑这样一种情况。我们往 ArrayList 插入大量元素后，又删除很多元素，此时底层数组会空闲处大量的空间。因为 ArrayList 没有自动缩容机制，导致底层数组大量的空闲空间不能被释放，造成浪费。对于这种情况，ArrayList 也提供了相应的处理方法，如下：

/**
    * 修改这个ArrayList实例的容量是列表的当前大小。 应用程序可以使用此操作来最小化ArrayList实例的存		   储。 
    */
   public void trimToSize() {
       modCount++;
       if (size < elementData.length) {
           elementData = (size == 0)
             ? EMPTY_ELEMENTDATA
             : Arrays.copyOf(elementData, size);
       }
   }

通过上面的方法，我们可以手动触发 ArrayList 的缩容机制。这样就可以释放多余的空间，提高空间利用率。

如下图：

扩容

对于变长数据结构，当结构中没有空余空间可供使用时，就需要进行扩容。在 ArrayList 中，当空间用完，其会按照原数组空间的1.5倍进行扩容。相关源码如下：

//下面是ArrayList的扩容机制
//ArrayList的扩容机制提高了性能，如果每次只扩充一个，
//那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。
   /**
    * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
    * @param   minCapacity   所需的最小容量
    */
   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);
       }
   }
/** 计算最小容量 */
private static int calculateCapacity(Object[] elementData, int minCapacity) {
   	if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
       	return Math.max(DEFAULT_CAPACITY, minCapacity);
   	}
   	return minCapacity;
   }

/** 扩容的入口方法 */
private void ensureCapacityInternal(int minCapacity) {
   	ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
 	//判断是否需要扩容
   private void ensureExplicitCapacity(int minCapacity) {
       modCount++;

       // overflow-conscious code
       if (minCapacity - elementData.length > 0)
           //调用grow方法进行扩容，调用此方法代表已经开始扩容了
           grow(minCapacity);
   }

   /**
    * 要分配的最大数组大小
    */
   private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

   /**
    * ArrayList扩容的核心方法。
    */
   private void grow(int minCapacity) {
       // oldCapacity为旧容量，newCapacity为新容量
       int oldCapacity = elementData.length;
       //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
       //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
       int newCapacity = oldCapacity + (oldCapacity >> 1);
       //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
       if (newCapacity - minCapacity < 0)
           newCapacity = minCapacity;
       //再检查新容量是否超出了ArrayList所定义的最大容量，
       //若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
       //如果minCapacity大于MAX_ARRAY_SIZE，则新容量则为Interger.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE。
       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);
   }
   //比较minCapacity和 MAX_ARRAY_SIZE
   private static int hugeCapacity(int minCapacity) {
       if (minCapacity < 0) // overflow
           throw new OutOfMemoryError();
       return (minCapacity > MAX_ARRAY_SIZE) ?
           Integer.MAX_VALUE :
           MAX_ARRAY_SIZE;
   }

接下来我们一步步分析ArrayList扩容机制，这里以无参构造函数创建的 ArrayList 为例分析。

1. 先来看看add 方法

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

2. 再来看看ensureCapacityInternal() 方法

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

   private static int calculateCapacity(Object[] elementData, int minCapacity) {
          if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
              return Math.max(DEFAULT_CAPACITY, minCapacity);
          }
          return minCapacity;
      }
      
      private void ensureCapacityInternal(int minCapacity) {
          ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
      }

   当要add进第1个元素时，minCapacity为1，在Math.max()方法比较后，minCapacity 为10。

3. ensureExplicitCapacity()方法

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

   //判断是否需要扩容
      private void ensureExplicitCapacity(int minCapacity) {
          modCount++;
      
          // overflow-conscious code
          if (minCapacity - elementData.length > 0)
              //调用grow方法进行扩容，调用此方法代表已经开始扩容了
              grow(minCapacity);
      }

   我们来仔细分析一下：

   • 当我们要 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(minCapacity) 方法。
   • 添加第3、4···到第10个元素时，依然不会执行grow方法，数组容量都为10。

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

4. grow()方法

   /**
       * 要分配的最大数组大小
       */
      private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
      
      /**
       * ArrayList扩容的核心方法。
       */
      private void grow(int minCapacity) {
          // oldCapacity为旧容量，newCapacity为新容量
          int oldCapacity = elementData.length;
          //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
          //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
          int newCapacity = oldCapacity + (oldCapacity >> 1);
          //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的	 		   新容量，
          if (newCapacity - minCapacity < 0)
              newCapacity = minCapacity;
         // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 			 和 MAX_ARRAY_SIZE，
         //如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 			 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
          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);
      }

   int newCapacity = oldCapacity + (oldCapacity >> 1),所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍！（JDK1.6版本以后）

   “>>”（移位运算符）：>>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() 方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!

5. hugeCapacity()方法

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

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

6. ensureCapacity()方法

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

   /**
       如有必要，增加此 ArrayList 实例的容量，以确保它至少可以容纳由minimum capacity参数指定的元素数。
        *
        * @param   minCapacity   所需的最小容量
        */
       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);
           }
       }

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

遍历

ArrayList 实现了 RandomAccess 接口（该接口是个标志性接口），表明它具有随机访问的能力。ArrayList 底层基于数组实现，所以它可在常数阶的时间内完成随机访问，效率很高。对 ArrayList 进行遍历时，一般情况下，我们喜欢使用 for each 循环遍历，但这并不是推荐的遍历方式。ArrayList 具有随机访问的能力，如果在一些效率要求比较高的场景下，更推荐下面这种方式：

for (int i = 0; i < list.size(); i++) {
    list.get(i);
}

至于原因也不难理解，for each 最终会被转换成迭代器遍历的形式，效率不如上面的遍历方式。

关于遍历时的删除

遍历时删除是一个不正确的操作，即使有时候代码不出现异常，但执行逻辑也会出现问题。关于这个问题，阿里巴巴 Java 开发手册里也有所提及。这里引用一下：

【强制】不要在 for each 循环里进行元素的 remove/add 操作。remove 元素请使用 Iterator 方式，如果并发操作，需要对 Iterator 对象加锁。

相关代码（稍作修改）如下：

	List<String> a = new ArrayList<String>();
	a.add("1");
	a.add("2");
	for (String temp : a) {
	    System.out.println(temp);
	    if("1".equals(temp)){
	        a.remove(temp);
	    }
	}
}

相信有些朋友应该看过这个，并且也执行过上面的程序。上面的程序执行起来不会虽不会出现异常，但代码执行逻辑上却有问题，只不过这个问题隐藏的比较深。

我们把 temp 变量打印出来，会发现只打印了数字1，2没打印出来。初看这个执行结果确实很让人诧异，不明原因。如果死抠上面的代码，我们很难找出原因，此时需要稍微转换一下思路。

我们都知道 Java 中的 for each 是个语法糖，编译成字节码后会被转成用迭代器遍历的方式。所以我们可以把上面的代码转换一下，等价于下面形式：

List<String> a = new ArrayList<>();
a.add("1");
a.add("2");
Iterator<String> it = a.iterator();
while (it.hasNext()) {
   	String temp = it.next();
   	System.out.println("temp: " + temp);
   	if("1".equals(temp)){
       	a.remove(temp);
   	}
}

这个时候，我们再去分析一下 ArrayList 的迭代器源码就能找出原因，代码如下：

	private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        // 并发修改检测，检测不通过则抛出异常
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }
    
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
    
    // 省略不相关的代码
}

我们一步一步执行一下上面的代码，第一次进入 while 循环时，一切正常，元素 1 也被删除了。但删除元素 1 后，就无法再进入 while 循环，此时 it.hasNext() 为 false。原因是删除元素 1 后，元素计数器 size = 1，而迭代器中的 cursor 也等于 1，从而导致 it.hasNext() 返回false。归根结底，上面的代码段没抛异常的原因是，循环提前结束，导致 next 方法没有机会抛异常。不信的话，大家可以把代码稍微修改一下，即可发现问题：

List<String> a = new ArrayList<>();
a.add("1");
a.add("2");
a.add("3");
Iterator<String> it = a.iterator();
while (it.hasNext()) {
   	String temp = it.next();
   	System.out.println("temp: " + temp);
   	if("1".equals(temp)){
       	a.remove(temp);
   	}
}

以上是关于遍历时删除的分析，在日常开发中，我们要避免上面的做法。正确的做法使用迭代器提供的删除方法，而不是直接删除。

System.arraycopy()和Arrays.copyOf()方法

System.arraycopy() 方法：

/**
    * 在此列表中的指定位置插入指定的元素。 
    *先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证		  capacity足够大；
    *再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
    */
   public void add(int index, E element) {
       rangeCheckForAdd(index);

       ensureCapacityInternal(size + 1);  // Increments modCount!!
       //arraycopy()方法实现数组自己复制自己
       //elementData:源数组;index:源数组中的起始位置;elementData：目标数组；index + 1：目标数组		   中的起始位置； size - index：要复制的数组元素的数量；
       System.arraycopy(elementData, index, elementData, index + 1, size - index);
       elementData[index] = element;
       size++;
   }

Arrays.copyOf()方法：

/**
    *以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。 
    *返回的数组将是“安全的”，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。
    *因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。
    */
   public Object[] toArray() {
   //elementData：要复制的数组；size：要复制的长度
       return Arrays.copyOf(elementData, size);
   }

两者的联系与区别

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

区别：

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

参考：

https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/ArrayList.md#systemarraycopy%E5%92%8Carrayscopyof%E6%96%B9%E6%B3%95

http://www.tianxiaobo.com/2018/01/31/LinkedList-%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90-JDK-1-8/#4%E6%80%BB%E7%BB%93