ArrayList源码分析

成员变量

 private transient Object[] elementData;

ArrayList内部实现的数组变量

private int size;

ArrayList包含的元素个数

构造函数部分

public ArrayList(int initialCapacity) {
	super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
	this.elementData = new Object[initialCapacity];
    }

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
	this(10);
    }

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayList(Collection<? extends E> c) {
	elementData = c.toArray();
	size = elementData.length;
	// c.toArray might (incorrectly) not return Object[] (see 6260652)
	if (elementData.getClass() != Object[].class)
	    elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

在构造ArrayList的时候可以指定大小，如果没有指定该参数默认大小为10。

对于集合参数的那个构造有这样一段代码

// c.toArray might (incorrectly) not return Object[] (see 6260652)
	if (elementData.getClass() != Object[].class)
	    elementData = Arrays.copyOf(elementData, size, Object[].class);

第一眼看到觉得很奇怪，java中有谁不是Object的子类？搜索了一下，原来这是一个bug， 详细说明见此。测试代码如下：

public static void main(String[] args) {
		List l = Arrays.asList(new String[]{"a", "b"});
	    System.out.println(l.toArray().getClass());
	    System.out.println(l.toArray(new Object[0]).getClass());
	}

输出结果：

class [Ljava.lang.String;
class [Ljava.lang.Object;

部分方法分析

trimToSize

public void trimToSize() {
	modCount++;
	int oldCapacity = elementData.length;
	if (size < oldCapacity) {
            elementData = Arrays.copyOf(elementData, size);
	}
    }

由于elementData的长度会被拓展，size标记的是其中包含的元素的个数。所以会出现size很小但elementData.length很大 的情况，将出现空间的浪费。trimToSize将返回一个新的数组给elementData，元素内容保持不变，length很size相同，节省空间。可在内存不足时使用。

ensureCapacity

 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

indexOf

 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;
    }

返回第一次出现某个元素的下标，未找到返回-1

lastIndexOf

 public int lastIndexOf(Object o) {
	if (o == null) {
	    for (int i = size-1; i >= 0; i--)
		if (elementData[i]==null)
		    return i;
	} else {
	    for (int i = size-1; i >= 0; i--)
		if (o.equals(elementData[i]))
		    return i;
	}
	return -1;
    }

返回最后一次出现某个元素的下标，未找到返回-1

clone

 public Object clone() {
	try {
	    ArrayList<E> v = (ArrayList<E>) super.clone();
	    v.elementData = Arrays.copyOf(elementData, size);
	    v.modCount = 0;
	    return v;
	} catch (CloneNotSupportedException e) {
	    // this shouldn't happen, since we are Cloneable
	    throw new InternalError();
	}
    }

覆写clone方法

toArray

public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

返回数组。注意返回的是新new的一个数组，那么你对这个返回的数组所执行的任何操作都不至于会影响到该ArrayList内部实现的数组。

public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
	System.arraycopy(elementData, 0, a, 0, size);
          if (a.length > size)
            a[size] = null;
	return a; }

首先判断传入的数组大小不能不够情况直接返回一个类型为T的新数组，当大小足够的情况下会将当前list中的元素拷贝之出入的数组中[0,size)的位置，但是之后的这个语句是什么意思呢？

 if (a.length > size)
            a[size] = null;

为什么要在大小大于size的情况下将a[size]设置为null？不懂就google吧。在csdn上找到这篇 帖子，意思说是分界用的。

add

 public boolean add(E e) {
	ensureCapacity(size + 1);  // Increments modCount!!
	elementData[size++] = e;
	return true;
    }

可以看出add方法每次在调用的时候都会调用扩容方法ensureCapacity，由此可见在构造ArrayList的时候设置大小很有作用，否则add每次扩容很消耗新能。

  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++;
    }

在指定位置插入元素

remove

 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;
    }

通过下标删除元素，如果删除的不是最后一个元素会执行数组拷贝操作。

public boolean remove(Object o) {
	if (o == null) {
            for (int index = 0; index < size; index++)
		if (elementData[index] == null) {
		    fastRemove(index);
		    return true;
		}
	} else {
	    for (int index = 0; index < size; index++)
		if (o.equals(elementData[index])) {
		    fastRemove(index);
		    return true;
		}
        }
	return false;
    }

删除某一对象，先找到该对象对应的下标，如果找到再通过下标删除。

addAll

public boolean addAll(Collection<? extends E> c) {
	Object[] a = c.toArray();
        int numNew = a.length;
	ensureCapacity(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
	return numNew != 0;
    }

将集合添加到list中，需要注意的是这个操作时不确定的当执行过程中被修改。

 public boolean addAll(int index, Collection<? extends E> c) {
	if (index > size || index < 0)
	    throw new IndexOutOfBoundsException(
		"Index: " + index + ", Size: " + size);

	Object[] a = c.toArray();
	int numNew = a.length;
	ensureCapacity(size + numNew);  // Increments modCount

	int numMoved = size - index;
	if (numMoved > 0)
	    System.arraycopy(elementData, index, elementData, index + numNew,
			     numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
	size += numNew;
	return numNew != 0;
    }

将集合添加到指定位置。该方法首先会扩容，然后将执行数组的拷贝。

总结

1. 从ArrayList的源码可以看出其底层是通过数组的方式来实现的，显然其访问速度比较快，相对来说插入和删除操作设计到数组的移动，故效率会低。

2. 虽然ArrayList会自动扩容，每次扩容和数组长度至少增加到原来的1.5倍+1，相对来说会有空间的浪费，而且频繁的扩容也会对性能产生影响，故在构造ArrayList的时候最好能指定长度。