ArrayList源码分析

ArrayList简介

ArrayList和vector的区别（了解即可）

ArrayList添加null值

ArrayList和LinkedList区别

ArrayList核心源码解读

ArrayList扩容机制分析

一步一分析ArrayList扩容机制

hugeCapacity()方法

System.arraycopy()

Arrays.copyOf()方法

ArrayList简介

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

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


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

List ：是一个列表，支持添加，删除，查找等操作，并且可以通过下标随机访问。

RandomAccess ：这是一个标志接口，表明实现这个接口的List结合支持快速随机访问的。在ArrayList中，我们即可通过元素的序号快速获取元素对象，这就是随机访问。

Cloneable：表明有拷贝能力，可以进行深拷贝或浅拷贝操作。

Serializable：表明他可以进行序列化操作，也就是可以将对象转换为字节流对象进行持久化存存储网络传输，非常方便。

ArrayList和vector的区别（了解即可）

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

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

ArrayList添加null值

ArrayList中可以存储任何类型的对象，包括null值。不过，不建议向ArrayList添加null值，null值毫无意义，会让代码难以维护比如忘记做判空处理就会导致空指针异常。

ArrayList<String> listOfStrings = new ArrayList<>();
listOfStrings.add(null);
listOfStrings.add("java");
System.out.println(listOfStrings);

[null, java]

ArrayList和LinkedList区别

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

底层数据结构：ArrayList底层使用的是Object数组；LinkedList底层使用的是双向链表数据结构（JDK1.6 之前为循环链表，JDK1.7 取消了循环。注意双向链表和双向循环链表的区别）

插入和删除是否受元素位置的影响：

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

LinkedList 采用链表存储，所以在头尾插入或者删除元素不受元素位置的影响（add(E e)、addFirst(E e)、addLast(E e)、removeFirst()、 removeLast()），时间复杂度为 O(1)，如果是要在指定位置 i 插入和删除元素的话（add(int index, E element)，remove(Object o),remove(int index)），时间复杂度为 O(n) ，因为需要先移动到指定位置再插入和删除。

是否支持快速随机访问： LinkedList 不支持高效的随机元素访问，而 ArrayList（实现了 RandomAccess 接口）支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。

内存空间占用： ArrayList 的空间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间（因为要存放直接后继和直接前驱以及数据）。

ArrayList核心源码解读

ArrayList扩容机制分析

先从构造函数说起，ArrayList有三种方式来进行初始化

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

一步一分析ArrayList扩容机制

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

add方法

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

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

ensureCapacityInternal方法源码如下：

// 根据给定的最小容量和当前数组元素来计算所需容量。
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));
}

ensureCapacityInternal方法非常简单，内部直接调用了ensureExplicitCapacity()方法：

//判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {modCount++;//判断当前数组容量是否足以存储minCapacity个元素if (minCapacity - elementData.length > 0)//调用grow方法进行扩容grow(minCapacity);
}

我们来分析一下：

1.当我们要add进第一个元素到ArrayList时，elementData.length为0，此时还是一个空数组，因为执行了ensureCapacityInternal方法，所以minCapacity此时为10.此时，minCapacity-elementData.length大于0，成立，所以会进入到grow(minCapacity);方法。

2.添加第3、4到第十个元素的时候，依然不会执行grow方法，数组容量都为10。

知道添加第11个元素的时候，minCapacity为11比elementData.length（10）要大。进入到grow方法进行扩容。

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 倍左右（oldCapacity 为偶数就是 1.5 倍，否则是 1.5 倍左右）！ 奇偶不同，比如：10+10/2 = 15, 33+33/2=49。如果是奇数的话会丢掉小数.

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) // overflowthrow 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;
}

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

System.arraycopy()

源码：

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

场景：

    /*** 在此列表中的指定位置插入指定的元素。*先调用 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++;}

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

public class ArraycopyTest {public static void main(String[] args) {// TODO Auto-generated method stubint[] 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

Arrays.copyOf()方法

源码：

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

场景：

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

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

public class ArrayscopyOfTest {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);}
}

结果：