深入 Java 集合系列之 ArrayList 源码解读

ArrayList 是 Java 最常用的集合之一，对于它的用法，我们再熟悉不过了。尽管很多人知道怎么去使用它，却鲜有人去阅读它的源码。至于为什么要阅读源码，这就用不着说了吧。接下来，进入 ArrayList 的源码学习。

首先，我们看它的构造函数，如下：

public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } public ArrayList(int initialCapacity) { if (initialCapacity > 0) { this.elementData = new Object[initialCapacity]; } else if (initialCapacity == 0) { this.elementData = EMPTY_ELEMENTDATA; } else { throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); } } public ArrayList(Collection c) { elementData = c.toArray(); if ((size = elementData.length) != 0) { // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; } } 

源码中给我们提供了 3 种不同构造函数，我们先看看它们的区别。第一种是默认的无参构造器，一般我们实例化 List 的时候，都喜欢使用这一种，它使用的是一维数组来保存这些数据，其默认大小为 10

transient Object[] elementData; /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; 

第二种构造器，传入的是一个大小，其大小就是数组的长度，也就是 List 的 size。如果你知道外部提供的数据的长度，那么可以直接传入一个固定值，这样会更好。原因是一旦数组定下来了，如要进行动态的增加长度，必定要拷贝旧的数据到新的数组里面，如果数据长度固定，就可以减少动态扩容的次数。

第三种构造器，它传入的是一个集合类，将这个传入的集合采用数组拷贝的方式进行赋值，然后去掉 native 方法，代码：

public static  T[] copyOf(U[] original, int newLength, Class newType) { @SuppressWarnings("unchecked") T[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength] : (T[]) Array.newInstance(newType.getComponentType(), newLength); System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; } 

 

看完了构造函数，接下来就是我们最常用的添加数据的方法了，添加数据有好几种方式，比如 add()、addAll()、set()等，首先我们来看看 add() 方法。

public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; } public void add(int index, E element) { if (index > size || index < 0) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); ensureCapacityInternal(size + 1); // Increments modCount!! System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; } 

第一种，当然是 add() 一个泛型数据了，当我们添加一个元素的时候，如果数组的长度不足的话，会进行扩容操作。

private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); } private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); } 

这里的 modCount 表示的是这个数据结构被修改的次数，就是说我们 add() 一次，表示把数据给修改了一次，它就会自增一次。扩容的话，调用的是 grow() 方法，我们最后来看。当然了， 如果充足，它会将 List 的 size++，并且将元素存放到数组里面。

第二种，是向 index 位置插入一个元素，这种情况肯定会去判断这个位置上是否有元素存在，如果有元素，则会将该位置及后面所以元素后移，然后才进行插入操作。同理，它的 size 也会 +1

add() 的方式就这两种，接着我们看 addAll() 的方式，它也有两种，代码如下：

public boolean addAll(Collection c) { Object[] a = c.toArray(); int numNew = a.length; ensureCapacityInternal(size + numNew); // Increments modCount System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; } public boolean addAll(int index, Collection c) { if (index > size || index < 0) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); Object[] a = c.toArray(); int numNew = a.length; ensureCapacityInternal(size + numNew); // Increments modCount int numMoved = size - index; if (numMoved > 0) System.arraycopy(elementData, index, elementData, index + numNew, numMoved); System.arraycopy(a, 0, elementData, index, numNew); size += numNew; return numNew != 0; } 

这个好像和我们的 add() 有点相似吧，不同的就是它添加的是一个集合类型，它首先会获取集合里面的类型对象，化为 Object[] 数组，接着获取数组的长度，进行拷贝一个新的数组实例，如果成功的话，size 就会加上 Object[] 的长度，当长度等于 0 时，返回的是 false，这样我们就可以观察数据有没有插入成功。第二个，是向 index 插入这个集合，方式和 add() 差不多，就不再多说了。

第三种添加数据的方式是：set() 方法，它的源码

public E set(int index, E element) { if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); E oldValue = (E) elementData[index]; elementData[index] = element; return oldValue; } 

 

我们看上面的代码，它会定义一个 oldValue 来存当前 index 的值，然后将要插入的新数据替换，并且最后将这个 oldValue 返回给我们。也就是插入一个新的数据，它会返回一个旧的数据。

好了，看完了所有的插入数据的源码，接着当然是获取数据的源码了，我们知道获取是 get() 方法，它的源码：

public E get(int index) { if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); return (E) elementData[index]; } 

这个再简单不过了吧，就是取出数组对应 index 位置的值。接下来，我们看看 List 是如何进行扩容的，源码如下：

private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0) newCapacity = minCapacity; 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); } private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; } 

它的扩容运算使用的是二进制 >> 右移运算，举个例子：比如我的 old 大小是 5，那么它的二进制是 101，那么 5 >> 1 后得到的二进制是 10，也就是十进制的 2，那么 new 就等于 5 + 2 = 7 。就是以这样的算法进行扩容的。其他代码倒是没什么的，还有当容量过大时，就会 oom 啦。

接下来是 remove() 移除方法，我们来看看源码：

public E remove(int index) { if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); modCount++; E oldValue = (E) 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; } 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 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 } 

remove() 有两种，一是 index ，二是元素。我们看它移除元素的时候，都会进行数组的重新拷贝，还有 size - 1，然后把移除的元素置空，这部分代码没什么好介绍的。

clear() 与 remove() 不同的是它移除的是所有的元素，就是把数组元素全部置空，然后 size = 0

public void clear() { modCount++; // clear to let GC do its work for (int i = 0; i < size; i++) elementData[i] = null; size = 0; } 接着看几个其他的方法，源码如下： public void trimToSize() { modCount++; if (size < elementData.length) { elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size); } } 

这个方法是得到 List 的真实大小，如果 List 的 size 小于数组元素的长度，就会重新得到一个真实大小的数组元素。

public int indexOf(Object o) { if (o == null) { for (int i = 0; i < size; i++) if (elementData[i]==null) return i; } else { for (int i = 0; i < size; i++) if (o.equals(elementData[i])) return i; } return -1; } public boolean contains(Object o) { return indexOf(o) >= 0; } 

 

这两个方法是判断某个元素是否存在 List 中，我们看第一个 o == null，表面 List 中的元素可以为 null 元素，indexOf() 如果找到该元素，会返回其值，否则返回 -1 。contains() 就更简单了，不用多说了吧。

public int lastIndexOf(Object o) { if (o == null) { for (int i = size-1; i >= 0; i--) if (elementData[i]==null) return i; } else { for (int i = size-1; i >= 0; i--) if (o.equals(elementData[i])) return i; } return -1; } 

这个 lastIndexOf() 是从 List 的 size 开始倒着遍历，用意很明显，就是获得指定元素的最后一个值，因为 List 中的元素可以是重复的，所有倒着遍历也是有其作用的。

当然了，在 ArrayList 中还有许多其他的方法，比如 sort() 、listIterator() 等，这些方法关联了其他很多的类来执行相应操作，我们就不进行介绍了，ArrayList 的核心操作方法源码就那么几个，文中可能还有一些没有提及的，可以自己去看看源码。