Java集合源码解读(2)-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)

你可能感兴趣的:(java,数据结构)