Java集合源码--ArrayList的解析

ArrayList可以看作是对一个数组的包装，实现可变数组。
1.ArrayList的基本字段

//保存真正元素的数组，这里可能大家会感到奇怪，为什么把这数组标记为transient，这
//样序列化时不能序列化这个数组了。所以之后就只能才能手动序列化保存ArrayList里
//的元素值了。虽说数组里保存的都是对象的引用，序列化的时候，也会把真正的对象序
//列化保存起来的。但是如果是直接不用transient修饰这个数组，那么序列化时，那些
//elementData中为null的空间也会序列化。一句话：我们序列化时，是序
//列化ArrayList里的真正的元素，而不是elementData这个数组。
private transient Object[] elementData;

//ArrayList元素的个数
private int size;

//这个字段其实是属于AbstractList类的，只不过ArrayList继承了过来。
//当ArrayList的结构发生变化时，这个字段都增1，比如调用add，remove等
//方法增加一个元素，删除一个元素时。
protected transient int modCount = 0;

2.ArrayList的构造方法
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException(“Illegal Capacity: “+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
其实就是根据指定大小initialCapacity创建一个数组。
public ArrayList() {
this(10);
}
可见，默认情况下，创建的ArrayList对象数组长度是10.

3.add方法
public boolean add(E e) {
ensureCapacity(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
增加一个元素时，第一步是检查数组空间是否够大，不够大，就扩展，就是变长数组的做法，其实就是创建另一个空间大一点的数组，把原来数组里的元素拷贝过去就是了；第二步就直接保存元素到数组里去。
public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1; //内部容器是如何扩展的
if (newCapacity < minCapacity)
newCapacity = minCapacity;
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
可以看到，如果在扩展时，新数组是原来数组的1.5倍，为什么是1.5倍呢，其实，这是一个考虑空间和时间平衡的结果。是个经验值，其实有些做法是扩展为原来的2倍。

对add方法的分析，如果不扩展数组时，增加一个元素是常量时间，如果扩展数组是，是O（n），但是总的来说，均摊的时间是常量。具体分析可以看相关讲解数据结构的书。
所以说，在ArrayList的尾部插入元素是比较快的 。

在ArrayList的指定位置插入元素时，平均时间是O(n)。 因为插入元素后面的元素需要进行移动。
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
“Index: “+index+”, Size: “+size);

ensureCapacity(size+1); // Increments modCount!!
System.arraycopy (elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
4.remove方法
这个方法也比较简单，平均时间为O(n)
public E remove(int index) {
RangeCheck(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; // Let gc do its work

return oldValue;
}
5.get方法
根据索引值直接得到元素，时间为常量。
public E get(int index) {
RangeCheck(index);

return (E) elementData[index];
}
6.contains方法
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
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;
}
可以看到，其实就是顺序的检索，不管成功与否，平均时间和最坏时间都是O(n)