ArrayList
ArrayList是基于动态数组实现的,支持随机访问,它继承自AbstractiList,RandomAccess标识着它支持随机访问
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
ArrayList的默认大小为10
private static final int DEFAULT_CAPACITY = 10;
它有如下三种构造方式:
ArrayList arr = new ArrayList();//默认大小为10
ArrayList arr1 = new ArrayList(5);//创建一个容量为5的ArrayList
ArrayList arr2 = new ArrayList(Collection<? extends E> c);//构造一个包含指定 collection 的元素的列表,这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
但是我们看接下来的源码
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
};
public ArrayList(){
super();
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
当我们使用无参的构造函数去构造一个ArrayList的时候,他会给elementData一个值,也就是说这个时候这个elementData数组还是没有容量的,并不是说创建之初容量就为默认容量10,那么它是在什么时候将容量扩容为10的呢,答案是加进第一个元素的时候
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
可以看到在ensureCapacityInternal中,有判断此时elementData数组的一个状态,如果值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA就会将容量设为默认容量
扩容
在ArrayList增加元素的时候,会使用ensureCapacityInternal()来确保容量足够,用grow()来扩容数组,扩容为原来的1.5倍
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
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);
}
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);
}
我们来捋一捋这个顺序
1、增加元素的时候,先用ensureCapacityInternal()确保容量足够,首先这个方法会判断你创建的是否是默认容量的ArrayList,然后调用ensureExplicitCapacity(),将所需容量大小传进去当参数
2、ensureExplicitCapacity()方法将modCount加1,这是个快速失败检查的标志,后面会讲到,同时在这个方法里面判断是否超过了容量大小,超了就执行grow()方法
3、我们看到grow()方法有两个判断,我们来分析一下
首先,这里将数组容量扩容到原本的1.5倍,oldCapacity>>1相当于oldCapacity/2;
int newCapacity = oldCapacity + (oldCapacity >> 1);
这是第一个判断,意思是如果扩容后的新容量仍然达不到要求的话,就将所需容量作为新容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
这是第二个判断,意思是如果扩容后的新容量超过了ArrayList的最大容量,就会调用hugeCapacity()方法,并传入所需容量作为参数,MAX_ARRAY_SIZE值为Integer.MAX_VALUE- 8,至于为什么是比整数的最大值小8,这就交给大神们去解答吧
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
最后,注意这里用了copyOf()来创建新的数组,所以每一次扩容对系统的耗费都很大,我们应该尽量在最开始的时候就给定大概的容量,减少扩容的次数
elementData = Arrays.copyOf(elementData, newCapacity);
删除元素
ArrayList删除元素的整体思路是用System.arraycopy()方法将index+1位置上的元素以及之后的元素前移,可以看出ArrayList删除元素的耗费是非常大的
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = 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;
}
Fail-Fast
Fail-Fast即快速失败机制,主要通过属性modCount来判断ArrayList的结构是否被修改,添加或者删除至少一个元素的所有操作,或者是调整内部数组的大小,都会改变ArrayList的结构,但是仅仅只是设置元素的值不算结构发生变化。
Fail-Fast机制是在进行序列化或者迭代等操作时,比较前后的modCount是否一样,如果改变了需要抛出 ConcurrentModificationException。
为什么要Fail-Fast机制呢,因为ArrayList不是线程安全的,如果有两个线程同时对一个ArrayList做修改的时候,每一方都是不知情的,这个时候就需要Fail-Fast机制来提醒线程此ArrayList被其他线程做了修改
我们可以看个例子,下面是序列化时需要使用的 ObjectOutputStream 的 writeObject() 方法
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++) {
s.