深入剖析ArrayList的构造函数、添加、获取、移除等核心方法，理解其内部实现机制。
博主声明：
转载请在开头附加本文链接及作者信息，并标记为转载。本文由博主 威威喵 原创，请多支持与指教。
本文首发于此 博主：威威喵 | 博客主页：https://blog.youkuaiyun.com/smile_running
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<? extends E> 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,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> 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<? extends E> 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<? extends E> 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 的核心操作方法源码就那么几个，文中可能还有一些没有提及的，可以自己去看看源码。
扫一扫
6987
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
