#ArrayList源码分析

https://www.cnblogs.com/zhangyinhua/p/7687377.html

https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/ArrayList-Grow.md

https://www.jianshu.com/p/2cd7be850540

1、ArrayList定义

public class ArrayList<E> extends AbstractList<E>  implements List<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

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

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

2、ArrayList的属性

1）、DEFAULT_CAPACITY：默认容量为10

/**
 * Default initial capacity.
   默认初始容量
 */
private static final int DEFAULT_CAPACITY = 10;

2）、EMPTY_ELEMENTDATA ：空数组,当调用无参数构造函数的时候默认给个空数组

/**
 * Shared empty array instance used for empty instances.
   用于空实例的共享空数组实例。
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

3）、DEFAULTCAPACITY_EMPTY_ELEMENTDATA：

/**
 * Shared empty array instance used for default sized empty instances. We
 * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
 * first element is added.
  用于默认大小的空实例的共享空数组实例。我们将其与EMPTY_ELEMENTDATA区分开来，了   解添加第一个元素时的膨胀程度。
  
 * 当调用无参构造方法，返回的是该数组。刚创建一个ArrayList 时，其内数据量为0。
 * 它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，而后者是在用户指定容量为0时返回。
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

4）、size ：ArrayList中实际元素的数量

/**
 * The size of the ArrayList (the number of elements it contains).
 *ArrayList的大小(它包含的元素的数量)。
 * @serial
 */
private int size;

5）、elementData：真正保存ArrayList中数据的数组

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * will be expanded to DEFAULT_CAPACITY when the first element is added.
 存储ArrayList元素的数组缓冲区。
ArrayList的容量是这个数组缓冲区的长度。任何空的ArrayList，当添加第一个元素时，带有elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 将被扩展为DEFAULT_CAPACITY。

被标记为transient，在对象被序列化的时候不会被序列化。
 */
transient Object[] elementData; 
// non-private to simplify nested class access非私有以简化嵌套类访问

3、ArrayList中的方法

1 、构造方法：

1）、默认构造函数

ArrayList()：无参构造方法：

/**
 * Constructs an empty list with an initial capacity of ten.
   构造一个初始容量为10的空列表。
   private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//属性3）
    }

第一个构造方法是无参的，构造方法里面的实现逻辑就是创建出一个空数组，这个数组是个静态常量，目的就是可以让所有对象可以复用，并且不能修改，这样就避免了每次都需要创建一个新的空数组问题。我们在使用无参构造方法创建list对象时，第一次插入数据就需要进行扩容。

2）、带初始容量参数的构造函数。（用户自己指定容量）

ArrayList(int initialCapacity)：构造一个ArrayList带容量大小的构造函数。

    /**
     * Constructs an empty list with the specified initial capacity.
     * 构造具有指定初始容量的空列表。
     * @param  initialCapacity  the initial capacity of the list 
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative  如果指定的初始容量为负，则抛出IllegalArgumentException
     */
    public ArrayList(int initialCapacity) {
        //判断参数值，初始容量大于0则创建出一个该长度的数组，
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            //初始容量等于0与无参构造方法一致
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            //小于0则会报错。
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

说明：DEFAULTCAPACITY_EMPTY_ELEMENTDATA与EMPTY_ELEMENTDATA的区别：

该数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA是默认返回的，而后者EMPTY_ELEMENTDATA是在用户指定容量为0时返回。

第二个构造方法是传递一个初始的长度，构造方法内判断参数值，大于0则创建出一个该长度的数组，等于0与无参构造方法一致，小于0则会报错。

3）、构造一个包含指定元素Collection的list

ArrayList(Collection<? extends E> c)：构造一个包含指定元素Collection的list，这些元素的是按照Collection的迭代器返回的顺序排列的

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
       构造一个列表，其中包含指定集合的元素，按集合的迭代器返回元素的顺序排列。
     *
     * @param c the collection whose elements are to be placed into this list
                要将其元素放入此列表的集合
     * @throws NullPointerException if the specified collection is null
               如果指定的集合为空，则为NullPointerException
     */
    public ArrayList(Collection<? extends E> c) {
        //将该集合数组化
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
             // c.toArray might (incorrectly) not return Object[] (see 6260652)       
             // 如果elementData不是Object类型数据（c.toArray可能返回的不是Object类型的数组所以加上下面的语句用于判断）
            // 返回若不是Object[]将调用Arrays.copyOf方法将其转为Object[]）。
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    } 

第三个构造方法则将提供的集合转成数组返回给elementData（返回若不是Object[]将调用Arrays.copyOf方法将其转为Object[]）。

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

阅读源码的话，我们就会发现 ArrayList 中大量调用了这两个方法。比如：我们上面讲的扩容操作以及add(int index, E element)、toArray() 等方法中都用到了该方法！

1）、Arrays.copyOf()方法:

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

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

package DataStructre.com.test;

import java.util.Arrays;

public class Test1 {
    public static void main(String[] args) {
        int[] a = new int[3];
        a[0] = 0;
        a[1] = 1;
        a[2] = 2;
        int[] b = Arrays.copyOf(a, 10);
        System.out.println("b.length"+b.length);
        for (int i = 0; i <a.length ; i++) {
            System.out.print(a[i]+" ");
        }
    }
}

b.length10
0 1 2

public static int[] copyOf(int[] original, int newLength) {
    int[] copy = new int[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

2）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++;
    }

我们写一个简单的方法测试以下：

javapublic class ArraycopyTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = new int[10];
		a[0] = 0;
		a[1] = 1;
		a[2] = 2;
		a[3] = 3;
		System.arraycopy(a, 2, a, 3, 3);
		a[2]=99;
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
	}

}

0 1 99 2 3 0 0 0 0 0 

3）两者联系和区别

联系：

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

区别：

arraycopy() 需要目标数组，将原数组拷贝到你自己定义的数组里或者原数组，而且可以选择拷贝的起点和长度以及放入新数组中的位置

copyOf() 是系统自动在内部新建一个数组，并返回该数组。

3、其他方法

size()

/**
     *返回此列表中的元素数。 
     */
    public int size() {
        return size;
    }

4、ArrayList的扩容机制：

1）add（）方法：

    /**
     * Appends the specified element to the end of this list.
     * 将指定的元素附加到此列表的末尾。
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        //进行扩容检查
        //确定内部容量是否够了，size是数组中数据的个数，因为要添加一个元素，所以size+1，先判断size+1的这个数 数组能否放得下，就在这个方法中去判断是否数组.length是否够用了。
        ensureCapacityInternal(size + 1);  // Increments modCount!!  增量 modCount
        //将e增加至list的数据尾部，容量+1
        //这里看到ArrayList添加元素的实质就相当于为数组赋值
        elementData[size++] = e;
        return true;
    }

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

2）ensureCapacityInternal(int minCapacity)：

目的：确定内部容量

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

   //得到最小扩容量
	private void ensureCapacityInternal(int minCapacity) {
         //利用 == 可以判断数组是否是用默认构造函数初始化的
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
             // 获取默认的容量和传入参数的较大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

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

3）ensureExplicitCapacity(int minCapacity)

判断是否需要扩容

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//如果确定要扩容，会修改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，此时e lementData.length(容量)在添加第一个元素后扩容成 10 了。此时，minCapacity - elementData.length > 0不成立，所以不会进入 （执行）grow(minCapacity) 方法。
• 添加第3、4···到第10个元素时，依然不会执行grow方法，数组容量都为10。

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

4）grow(int minCapacity)

ArrayList扩容的核心方法。

/**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
     /**
     * 要分配的最大数组大小
     */
    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 倍左右（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() 方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!

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;
    }