ArrayList源码分析(基于JDK1.8)

ArrayList的继承关系

ArrayList的成员变量

//初始化默认容量
private static final int DEFAULT_CAPACITY = 10;
// 空对象数组
private static final Object[] EMPTY_ELEMENTDATA = {};
// 默认容量的空对象数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 实际存储对象的数组
transient Object[] elementData;
// 存储的数量
private int size;
// 数组能申请的最大数量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

1.add(E e)，最常用的，其他添加元素的方法和这个方法的实现都差不多

public boolean add(E e) {
ensureCapacityInternal(size + 1);  // Increments modCount!!
elementData[size++] = e;
return true;
}

在添加元素之前，所有方法都会进行一次检查，是否需要进行扩容，如果在指定位置添加元素，则会调用

rangeCheckForAdd(index)

对index进行检查，是否越界
重点看一下

ensureCapacityInternal(size + 1)

方法

private void ensureCapacityInternal(int minCapacity) {
//这个判断是针对默认构造函数
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//在小于10之前最大值一直都是DEFAULT_CAPACITY
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}

ensureExplicitCapacity(minCapacity);
}

为什么说那个if判断是针对默认构造函数的呢
默认构造函数：

public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

而

Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}

其实默认构造函数并没有对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);
}
}

是直接对elementData进行了一个初始化的

ensureCapacityInternal(int minCapacity)

方法会调用

ensureExplicitCapacity(minCapacity)

方法

private void ensureExplicitCapacity(int minCapacity) {
modCount++;

// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}

modCount记录的是对数据结构进行修改的次数
如果添加了一个数组元素以后会导致数组溢出，就会进行扩容，真正进行扩容操作的是grow()函数

private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//扩大为原来的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//超过容器允许的最大值
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 进行数组拷贝
elementData = Arrays.copyOf(elementData, newCapacity);
}

所以对于调用默认构造函数时，数组的初始化是在第一次添加元素的时候调用grow()函数进行初始化的，对于已经初始化的容器，扩容以后扩大为原容器的1.5倍，而对于没有进行初始化的容器（即调用默认构造函数）初始化为10。如果扩容以后超过最大值将调用

hugeCapacity(int minCapacity)

方法

private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}

超过最大值以后（扩容1.5倍），则只能扩容为最大值的大小

3.4.3 remove(int index)

public E remove(int index) {
rangeCheck(index);
// 修改计数器
modCount++;
// 记录旧值，返回
E oldValue = elementData(index);
// 计算要往前移动的元素个数
int numMoved = size - index - 1;
//个数大于0，进行拷贝，从index+1开始，拷贝numMoved个，拷贝起始位置是index
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 设置为null，以便GC
elementData[--size] = null;
return oldValue;
}

对于被删除的元素，其后面的元素需要往前移。

3.4.4 remove(Object o)

public boolean remove(Object o) {
// 判断o为null，loop遍历找到为null的元素
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
// 不为null
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}

// 与上面的remove(int index) 类似
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;
}

3.4.5 set(int index, E element)

public E set(int index, E element) {
rangeCheck(index);
// 记录旧的值
E oldValue = elementData(index);
//在原位置设置新的值
elementData[index] = element;
return oldValue;
}

设置index位置的元素值为element，返回该位置的原来的值

3.4.6 addAll(Collection<? extends E> c)

public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
// 对于新的最小长度进行判断处理
ensureCapacityInternal(size + numNew);
//将a数组，从index-0开始，拷贝numNew个，到elementData的size位置
System.arraycopy(a, 0, elementData, size, numNew);
//将size增加numNew个
size += numNew;
return numNew != 0;
}

转载来自：https://www.imooc.com/article/22259  https://www.jianshu.com/p/aa582f6552b4