ArrayList源码分析

1, 结构图

ArrayList 是android中很常见的一种数据结构,经常用,现在就来分析一下源码吧,结构图如下,



其继承结构从上往下论述。

1.1, Iterable  Iterator

这两个都是接口,实现他们的方法就可以对集合进行遍历

public interface Iterable<T> {
Iterator<T> iterator();
}

public interface Iterator<E> {
public boolean hasNext();
public E next();
public void remove();
}

2.2, Collection  AbstractCollection

Collection 接口共有15个方法,其中iterator从Iterable 继承而来。如下,



AbstractCollection是一个抽象类,继承了Collection,实现了部分方法。

2.3, List  AbstractList

List只是一个接口,提供一些方法, AbstractList实现了部分方法。list中的方法如下,

2, ArrayList分析

首先看看ArrayList的构造方法

2.1, 构造方法

ArrayList一共有三个构造方法,从最简单的开始分析,

public ArrayList() {
array = EmptyArray.OBJECT;
}
Array定义如下,

transient Object[] array;

transient关键字是啥意思?

在序列化对象时,在array前面加上transient关键字是不会进行系列化的。

那么 EmptyArray.OBJECT又是什么呢?

在EmptyArray中的定义如下，

public static final Object[] OBJECT = new Object[0];

原来构造了一个大小为0 的Object数组。

 

第二个构造方法也挺简单, 构造了一个大小为capacity 的Object数组。

public ArrayList(int capacity) {
if (capacity < 0) {
throw new IllegalArgumentException("capacity < 0: " + capacity);
}
array = (capacity == 0 ? EmptyArray.OBJECT : new Object[capacity]);
}第三个构造方法将其他集合转化为ArrayList。

2.2, add方法

Add有四个方法,

1,在array的最后添加一个元素

2,在任一位置添加一个元素

3,在array的最后添加一个集合(Collection)

4, 在任一位置添加一个集合

这4个方法的本质是一样的,以第一种为例来论述,

@Override public boolean add(E object) {
Object[] a = array;
int s = size;
if (s == a.length) {
Object[] newArray = new Object[s +
(s < (MIN_CAPACITY_INCREMENT / 2) ?
MIN_CAPACITY_INCREMENT : s >> 1)];
System.arraycopy(a, 0, newArray, 0, s);
array = a = newArray;
}
a[s] = object;
size = s + 1;
modCount++;
return true;
}

private static final int MIN_CAPACITY_INCREMENT = 12;

array最开始是大小为0的数组,是怎么添加元素的呢?

Array. Length 表示的是实际申请的数组大小,而size表示Array中已使用的数组大小。并且数组的大小翻倍申请的,太过频繁申请会影响效率。所以,使用的时候一定是size方法而不是Length方法。

 

Remove 有2种方法,

1,删除任一位置的元素

2,删除特定的元素。

 

get (intindex) 得到指定位置的元素

size()数组的大小

isEmpty() 判断array中的元素是否为空,

注意: 不要使用array. Length为0来判断。

Contains(Object object) array数组中是否包含对象

indexOf(Object object) 返回对象最开始出现的位置

lastIndexOf(Object object) 返回对象最后出现的位置

trimToSize() 将array数组简单整理

hashCode()array数组的哈希码

set(int index, E object)将第index的元素替换为object

3, 接口实现

3.1, Iterable  Iterator

继承Iterable 只是表面的,主要是继承Iterator

 @Override public Iterator<E> iterator() {
return new ArrayListIterator();
}
ArrayListIterator是什么?是ArrayList的内部类并且实现了对应的方法,这样就可以使用iterator方法来进行循环了。

private class ArrayListIterator implements Iterator<E> {
/** Number of elements remaining in this iteration */
private int remaining = size;

/** Index of element that remove() would remove, or -1 if no such elt */
private int removalIndex = -1;

/** The expected modCount value */
private int expectedModCount = modCount;

public boolean hasNext() {
return remaining != 0;
}

@SuppressWarnings("unchecked") public E next() {
ArrayList<E> ourList = ArrayList.this;
int rem = remaining;
if (ourList.modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
if (rem == 0) {
throw new NoSuchElementException();
}
remaining = rem - 1;
return (E) ourList.array[removalIndex = ourList.size - rem];
}

public void remove() {
Object[] a = array;
int removalIdx = removalIndex;
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
if (removalIdx < 0) {
throw new IllegalStateException();
}
System.arraycopy(a, removalIdx + 1, a, removalIdx, remaining);
a[--size] = null;  // Prevent memory leak
removalIndex = -1;
expectedModCount = ++modCount;
}
}

3.2, Cloneable

继承了Cloneable接口,就必须实现clone方法,这样该类才可以进行clone。但是,

Cloneable接口中没有任何方法?这不符合一般的逻辑啊!

Java有一个特性,就是所有的java类都继承自Object

类,而clone方法是在Object类中定义的,其定义如下,

protected Object clone() throws CloneNotSupportedException {
if (!(this instanceof Cloneable)) {
throw new CloneNotSupportedException("Class " + getClass().getName() +
" doesn't implement Cloneable");
}

return internalClone();
}

原来是这样的, Cloneable只是调用clone方法的一个声明。

1,要想调用Object类的clone方法,必须继承Cloneable接口

2,继承了Cloneable接口不一定非要实现clone方法。

问题:复制在其他地方论述。

3.3, RandomAccess

RandomAccess接口里也没有什么方法,也只是一个标记,标志着什么呢?

直接看ArrayList的equals方法,

@Override public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof List)) {
return false;
}
List<?> that = (List<?>) o;
int s = size;
if (that.size() != s) {
return false;
}
Object[] a = array;
if (that instanceof RandomAccess) {
for (int i = 0; i < s; i++) {
Object eThis = a[i];
Object ethat = that.get(i);
if (eThis == null ? ethat != null : !eThis.equals(ethat)) {
return false;
}
}
} else {  // Argument list is not random access; use its iterator
Iterator<?> it = that.iterator();
for (int i = 0; i < s; i++) {
Object eThis = a[i];
Object eThat = it.next();
if (eThis == null ? eThat != null : !eThis.equals(eThat)) {
return false;
}
}
}
return true;
}

从上面的代码中可以看出,如果一个集合继承了RandomAccess接口,那么必然会有get方法,就可以使用其get方法来获取元素,否则只能用iterator。那么可以这样理解,集合类如何继承了RandomAccess接口,那么必然会有一个get方法。

问题: get方法和 iterator 哪一个的效率更高呢?

Equals方法是判断两个集合中的每个元素是不是完全相同。

3.4 Serializable

Serializable简单说就是保存对象的实例变量状态,并且可以将保存的状态读取出来。

Serializable接口也没有任何方法,除了继承之外,还要有一个哈希码,直接看源码

private static final long serialVersionUID = 8683452581122892189L;

private void writeObject(ObjectOutputStream stream) throws IOException {
stream.defaultWriteObject();
stream.writeInt(array.length);
for (int i = 0; i < size; i++) {
stream.writeObject(array[i]);
}
}

private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
stream.defaultReadObject();
int cap = stream.readInt();
if (cap < size) {
throw new InvalidObjectException(
"Capacity: " + cap + " < size: " + size);
}
array = (cap == 0 ? EmptyArray.OBJECT : new Object[cap]);
for (int i = 0; i < size; i++) {
array[i] = stream.readObject();
}
}

由此看到,进行系列化和反系列化时,只是简单仅针对array数组值。

问题: Serializable 和 Parcelable 的区别。

4, 横向比较

从源码中看, Vector和ArrayList很像,都是继承AbstractList等,那么他们之间有哪些区别呢?

1, Vector有些方法使用关键字synchronized进行修饰,所以Vector是线程安全的,导致Vector在效率上低于ArrayList。

2,都是采用线性连续空间存储元素,当空间不足时,2个类增加方法是不同的。

ArrayList一次可以增长自身空间的一半,而Vector可以设置增长因子。

 

现在一般很少使用Vector了。

Stack继承Vector,只是多了几个方法而已,