我们就ArrayList的以下特点来进行源码分析:
1.线程不安全,存放元素是有序的;
2.自动扩容到原来的1.5倍;
3.默认容量为10;
4.数据结构:基于数组实现,类型为Object类型;
5.get方法是通过元素下表进行查询,而不是元素值;
我们将上面的2,3问题放在一起讲解
1.底层数据结构
首先因为ArrayList的底层没有像Vector一样加同步锁,因此它是线程不安全的;
它的底层实现是数组,因此它存放元素是有序的:
//存放我们添加的元素;
transient Object[] elementData;
2.get方法
在讲这个之前,我们先简单了解一下时间复杂度的概念:
时间复杂度分为O(1),O(n),O(logn)
O(1)
只需要通过查询一次就能找到目标元素;
O(n)
需要从头查询到尾部,例如根据元素值去查询;
O(logn),
例如二叉树,红黑树这种特殊数据结构的查询方法;
好,在简单了解之后再来思考我们的问题,get方法为什么不根据具体的元素进行查询,而是根据下标进行查询?
通过元素下标直接查询,我们可以精确的定位到元素,因此只需要查询一次,时间复杂度为O(1),效率很高;
而如果根据具体的元素去查询,那么就需要进行循环遍历,直到找到我们指定的目标元素,时间复杂度为O(n),效率较低;
3.初始化机制及自动扩容机制
ArrayList的初始化机制和自动扩容机制主要体现在add方法上面;
当我们在调用add方法的时候,会传入一个默认的size+1的参数,这个size是数组的长度的,默认值为0,也就是说当我们在第一次调用这个方法的时候,传给下面这个方法的参数值为1;
ensureCapacityInternal(size + 1);
这个值又会作为minCapacity参数被带入下面这个方法
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
我们先一步一步看避免混淆
首先当前这个数组elementData,和传入的size+1参数进入到下面这个calculateCapacity方法中
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
在这个方法中,先判断当前数组是否为空,如果为空那么则在默认的容量10和我们传过来的size+1中取最大值并返回,否则就直接返回minCapacity(也就是最开始的size+1);
private static final int DEFAULT_CAPACITY = 10;
其实这一步就是做的初始化操作,因为我们第一次调用add方法,传过来的数据size+1的结果=1,因此取最大的肯定也就是默认容量10了;
然后这个返回值就会传入外部的ensureExplicitCapacity方法;
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
在这个方法中,判断minCapacity是否大于当前数组的长度,如果大于的话则调用grow方法进行扩容;(假设我们这里还是minCapacity还是第一次到这个地方,那么值依旧1,那么也会进入到grow方法里面)也就是说最核心的操作就是在grow方法中进行的,我们再往下看grow方法:
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);
}
在grow方法中我们可以清晰的看到,首先他获取到了当前数组的长度,作为旧容量(oldCapacity),再将旧容量+旧容量往右移动1位(除以二),得到新容量(newCapacity)
这里也就解释了为什么自动扩容是原先的1.5倍了
再往下看,它判断新容量是否小于我们传过来的(size+1),如果小于则将我们传过来的值赋给新容量,这一步的操作是为什么呢?
还是回到我们上面第一次调用这个方法的时候,传过来的size+1是不是1呢,那么旧容量也就是0,新容量=0+0除以2还是等于0,那么这个时候就会走到这个方法,最终将我们的size+1赋值给新容量,也就是说这个判断也是帮助做初始化工作的;
而下面的判断MAX_ARRAY_SIZE值,是Integer包装类的最大值-8
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
而这个MAX_VALUE的值是2的31次方-1,因此正常情况是不会走到这个判断内部的,主要是增强操作;
那么最后的扩容操作就是Arrays类下面的copyof方法了
这个方法就是根据我们传入的数组长度(第二个参数newCapacity),生成一个新的数组,并且将我们传入的数组(第一个参数elementData,也就是我们扩容前的数组/刚刚创建的数组),copy到这个新数组中并返回。
4.remove方法以及缩容机制
remove方法其实就是将目标元素后面的所有元素整体往前移动一位;
remove方法也有两种实现,一种是基于元素内容删除,时间复杂度为O(n),另一种是根据元素的下标进行删除,时间复杂度为O(1);
我们在删除的时候就需要考虑缩容问题;
缩容
我们在进行删除之后,目标元素后面的所有元素整体往前移动了一位,那么最后一个位置的元素就为空;
例如在根据元素值进行删除的remove方法中,它先通过循环遍历,找到了该元素的下标,然后将下标传入了下面这个fastRemove方法中:
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
}
在这个方法中,首先计算了numMoved(删除的目标元素的后面的元素个数)即需要被移动的元素个数;
然后再调用System里面的arraycopy方法:
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
//Object src:原数组;
//int srcPos:从原数据的起始位置开始;
//Object dest:目标数组
//int destPos:目标数组的开始起始位置;
//int length:要copy的数组的长度;
该方法的意思就是:从原数组的指定位置开始,截取指定长度copy到从目标数组的指定位置开始;
最后再将最后一个位置设置为空;
5.modCount的作用
我们刚刚在看remove和add方法源码的时候会发现,在核心方法的最开始总是会有一个modcount++,那么这个modcount是什么呢?
我们刚刚在研究add和remove方法的时候,都是在单线程的思维下进行的,如果场景变为多线程场景,就有可能出现下面这个问题:
A线程在遍历集合,而B线程在对这个集合存放数据,那么就有可能导致A线程一直在遍历造成死循环;
因此我们加入这个modCount值进行记录判断;
我们在进行集合的foreach遍历的时候,查看它的源码会发现:
public void forEach(Consumer<? super E> action) {
Objects.requireNonNull(action);
final int expectedModCount = modCount;
@SuppressWarnings("unchecked")
final E[] elementData = (E[]) this.elementData;
final int size = this.size;
for (int i=0; modCount == expectedModCount && i < size; i++) {
action.accept(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
它在遍历之前会先拿到我们的modCount值,如果我们在遍历的时候这个modCount值发生了变化,说明有其他线程操作了当前线程的这个集合,那么就会抛出ConcurrentModificationException异常;
modCount这个机制也叫做fastClass机制。