java ArrayList源码解析

public class ArrayList<E> extends AbstractList<E> implements List<E>,
	RandomAccess, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.初始化容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 实际存储对象时数组 transient:序列化的时候不会被序列化
     */
    private transient Object[] elementData;

    /**
     * arrayList的大小
     */
    private int size;

    /**
     * 
     */
    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() {
	super();
	this.elementData = EMPTY_ELEMENTDATA;
    }

    /**
     * 
     */
    public ArrayList(Collection<? extends E> c) {
	elementData = c.toArray();
	size = elementData.length;
	// 若果elementData的类型 不为Object[] ，则转换成Object[]
	if (elementData.getClass() != Object[].class)
	    elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

    /**
     * ArrayList 内部的array[]的大小是以2的指数增长的, 即 oldLength = oldLength + oldLength*2;
     * 这样就会有很多空的元素，这个方法的作用就是把空的元素去掉，节省存储空间
     */
    public void trimToSize() {
	modCount++;
	if (size < elementData.length) {
	    elementData = Arrays.copyOf(elementData, size);
	}
    }

    /**
     * 
     */
    public void ensureCapacity(int minCapacity) {
	int minExpand = (elementData != EMPTY_ELEMENTDATA)
	// any size if real element table
	? 0
		// larger than default for empty table. It's already supposed to
		// be
		// at default size.
		: DEFAULT_CAPACITY;

	if (minCapacity > minExpand) {
	    ensureExplicitCapacity(minCapacity);
	}
    }

    private void ensureCapacityInternal(int minCapacity) {
	if (elementData == 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 static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * 增长 ArrayList的 array ,扩展ArrayList
     */
    private void grow(int minCapacity) {
	// overflow-conscious code
	int oldCapacity = elementData.length;
	int newCapacity = oldCapacity + (oldCapacity >> 1);// 增加2倍
	if (newCapacity - minCapacity < 0)// 增加2倍的值 小于 参数的增长值，
	    newCapacity = minCapacity;// 增长的值 为参数，否则增长的值为newCapacity
	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);
    }

    /**
     * 取array长度最大值
     * 
     * @param minCapacity
     * @return
     */
    private static int hugeCapacity(int minCapacity) {
	// 增长不能为负数
	if (minCapacity < 0) // overflow
	    throw new OutOfMemoryError();
	return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE
		: MAX_ARRAY_SIZE;
    }

    /**
     * 返回arraylist当前存储了多少个 元素
     */
    public int size() {
	return size;
    }

    /**
     * 判断ArrayList是否为空,即存储的元素个数是否为0
     */
    public boolean isEmpty() {
	return size == 0;
    }

    /**
     * ArrayList 是否包含这个元素，调用 indexOf() indexOf(o) >= 0 包含改元素
     */
    public boolean contains(Object o) {
	return indexOf(o) >= 0;
    }

    /**
     * 返回元素在ArrayList第一次出现的位置，不存在返回-1
     */
    public int indexOf(Object o) {
	if (o == null) {// null 等号判断
	    for (int i = 0; i < size; i++)
		if (elementData[i] == null)
		    return i;
	} else { // 非null equals判断对象是否相等
	    for (int i = 0; i < size; i++)
		if (o.equals(elementData[i]))
		    return i;
	}
	return -1;
    }

    /**
     * 同上，对象最后出现在ArrayList的位置，不存在返回-1
     */
    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;
    }

    /**
     * 克隆arrayList对象
     */
    public Object clone() {
	try {
	    @SuppressWarnings("unchecked")
	    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();
	}
    }

    /**
     * 返回arrayList的数组形式，新建一个数组，并不是用的ArrayList内部的数组
     */
    public Object[] toArray() {
	return Arrays.copyOf(elementData, size);
    }

    /**
     * arrayList复制到参数的数组中
     */
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
	if (a.length < size)// 如果参数 数组的长度小于 arrayList的长度，截取arrayList
	    // 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;
    }

    // Positional Access Operations

    @SuppressWarnings("unchecked")
    E elementData(int index) {
	return (E) elementData[index];
    }

    /**
     * 去arrayList的弄个元素的值
     */
    public E get(int index) {
	rangeCheck(index);// 边界检查 ，查出边界 抛出异常

	return elementData(index);
    }

    /**
     * arrayList设置新的值，返回旧的值
     */
    public E set(int index, E element) {
	rangeCheck(index);// 边界检查 ，查出边界 抛出异常

	E oldValue = elementData(index);
	elementData[index] = element;
	return oldValue;
    }

    /**
     * arrayList添加元素到尾部
     */
    public boolean add(E e) {
	ensureCapacityInternal(size + 1); // 添加之前先扩展内部array容量
	elementData[size++] = e;
	return true;
    }

    /**
     * 
     */
    public void add(int index, E element) {
	rangeCheckForAdd(index);

	ensureCapacityInternal(size + 1); // Increments modCount!!
	System.arraycopy(elementData, index, elementData, index + 1, size
		- index);
	elementData[index] = element;
	size++;
    }

    /**
     * 移除index处的值,index后的值往前移动
     */
    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; // 移动完之后，原来以后一个位置的对象仍然存在，array存在该对象的引用，该对象不能被垃圾回收

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

    /*
     * Private remove method that skips bounds checking and does not return the
     * value removed.
     */
    private void fastRemove(int index) {
	modCount++;
	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
    }

    /**
     * 
     */
    public void clear() {
	modCount++;

	// clear to let GC do its work
	for (int i = 0; i < size; i++)
	    elementData[i] = null;

	size = 0;
    }

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

    /**
     * 
     */
    public boolean addAll(int index, Collection<? extends E> c) {
	rangeCheckForAdd(index);

	Object[] a = c.toArray();
	int numNew = a.length;
	ensureCapacityInternal(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;
    }

    /**
     * 
     */
    protected void removeRange(int fromIndex, int toIndex) {
	modCount++;
	int numMoved = size - toIndex;
	System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved);

	// clear to let GC do its work
	int newSize = size - (toIndex - fromIndex);
	for (int i = newSize; i < size; i++) {
	    elementData[i] = null;
	}
	size = newSize;
    }

    private void rangeCheck(int index) {
	if (index >= size)
	    throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * A version of rangeCheck used by add and addAll.
     */
    private void rangeCheckForAdd(int index) {
	if (index > size || index < 0)
	    throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private String outOfBoundsMsg(int index) {
	return "Index: " + index + ", Size: " + size;
    }

    /**
     * 移除ArrayList中包含c的元素
     */
    public boolean removeAll(Collection<?> c) {
	return batchRemove(c, false);
    }

    /**
     * c中有的元素不移除
     */
    public boolean retainAll(Collection<?> c) {
	return batchRemove(c, true);
    }

    /**
     * removeAll retainAll 通过开关complement判断是移除c中有的还是移除不存在c中的
     */
    private boolean batchRemove(Collection<?> c, boolean complement) {
	final Object[] elementData = this.elementData;
	int r = 0, w = 0;
	boolean modified = false;
	try {
	    for (; r < size; r++)
		if (c.contains(elementData[r]) == complement)// complement=false
		    elementData[w++] = elementData[r];// 把c中不存在的往数组前面移动
	} finally {
	    // Preserve behavioral compatibility with AbstractCollection,
	    // even if c.contains() throws.
	    if (r != size) {// 原则上应该r==size,不等的情况可能是被中断了吧，被中断后保重中断前的操作生效
		System.arraycopy(elementData, r, elementData, w, size - r);
		w += size - r;// w 等于数组有效元素的下一个位置
	    }
	    if (w != size) {// w != size表示有移动，
		// clear to let GC do its work
		for (int i = w; i < size; i++)
		    elementData[i] = null;
		modCount += size - w;
		size = w;
		modified = true;
	    }
	}
	return modified;
    }

    /**
     * Save the state of the <tt>ArrayList</tt> instance to a stream (that is,
     * serialize it).
     * 
     * @serialData The length of the array backing the <tt>ArrayList</tt>
     *             instance is emitted (int), followed by all of its elements
     *             (each an <tt>Object</tt>) in the proper order.
     */
    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.writeObject(elementData[i]);
	}

	if (modCount != expectedModCount) {
	    throw new ConcurrentModificationException();
	}
    }

    /**
     * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
     * deserialize it).
     */
    private void readObject(java.io.ObjectInputStream s)
	    throws java.io.IOException, ClassNotFoundException {
	elementData = EMPTY_ELEMENTDATA;

	// Read in size, and any hidden stuff
	s.defaultReadObject();

	// Read in capacity
	s.readInt(); // ignored

	if (size > 0) {
	    // be like clone(), allocate array based upon size not capacity
	    ensureCapacityInternal(size);

	    Object[] a = elementData;
	    // Read in all elements in the proper order.
	    for (int i = 0; i < size; i++) {
		a[i] = s.readObject();
	    }
	}
    }

    /**
     * Returns a list iterator over the elements in this list (in proper
     * sequence), starting at the specified position in the list. The specified
     * index indicates the first element that would be returned by an initial
     * call to {@link ListIterator#next next}. An initial call to
     * {@link ListIterator#previous previous} would return the element with the
     * specified index minus one.
     * 
     * <p>
     * The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     * 
     * @throws IndexOutOfBoundsException
     *             {@inheritDoc}
     */
    public ListIterator<E> listIterator(int index) {
	if (index < 0 || index > size)
	    throw new IndexOutOfBoundsException("Index: " + index);
	return new ListItr(index);
    }

    /**
     * Returns a list iterator over the elements in this list (in proper
     * sequence).
     * 
     * <p>
     * The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     * 
     * @see #listIterator(int)
     */
    public ListIterator<E> listIterator() {
	return new ListItr(0);
    }

    /**
     * Returns an iterator over the elements in this list in proper sequence.
     * 
     * <p>
     * The returned iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     * 
     * @return an iterator over the elements in this list in proper sequence
     */
    public Iterator<E> iterator() {
	return new Itr();
    }

    /**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator<E> {
	int cursor; // index of next element to return
	int lastRet = -1; // index of last element returned; -1 if no such
	int expectedModCount = modCount;

	public boolean hasNext() {
	    return cursor != size;
	}

	@SuppressWarnings("unchecked")
	public E next() {
	    checkForComodification();
	    int i = cursor;
	    if (i >= size)
		throw new NoSuchElementException();
	    Object[] elementData = ArrayList.this.elementData;
	    if (i >= elementData.length)
		throw new ConcurrentModificationException();
	    cursor = i + 1;
	    return (E) elementData[lastRet = i];
	}

	public void remove() {
	    if (lastRet < 0)
		throw new IllegalStateException();
	    checkForComodification();

	    try {
		ArrayList.this.remove(lastRet);
		cursor = lastRet;
		lastRet = -1;
		expectedModCount = modCount;
	    } catch (IndexOutOfBoundsException ex) {
		throw new ConcurrentModificationException();
	    }
	}

	final void checkForComodification() {
	    if (modCount != expectedModCount)
		throw new ConcurrentModificationException();
	}
    }

    /**
     * An optimized version of AbstractList.ListItr
     */
    private class ListItr extends Itr implements ListIterator<E> {
	ListItr(int index) {
	    super();
	    cursor = index;
	}

	public boolean hasPrevious() {
	    return cursor != 0;
	}

	public int nextIndex() {
	    return cursor;
	}

	public int previousIndex() {
	    return cursor - 1;
	}

	@SuppressWarnings("unchecked")
	public E previous() {
	    checkForComodification();
	    int i = cursor - 1;
	    if (i < 0)
		throw new NoSuchElementException();
	    Object[] elementData = ArrayList.this.elementData;
	    if (i >= elementData.length)
		throw new ConcurrentModificationException();
	    cursor = i;
	    return (E) elementData[lastRet = i];
	}

	public void set(E e) {
	    if (lastRet < 0)
		throw new IllegalStateException();
	    checkForComodification();

	    try {
		ArrayList.this.set(lastRet, e);
	    } catch (IndexOutOfBoundsException ex) {
		throw new ConcurrentModificationException();
	    }
	}

	public void add(E e) {
	    checkForComodification();

	    try {
		int i = cursor;
		ArrayList.this.add(i, e);
		cursor = i + 1;
		lastRet = -1;
		expectedModCount = modCount;
	    } catch (IndexOutOfBoundsException ex) {
		throw new ConcurrentModificationException();
	    }
	}
    }

    /**
     * 返回原arrayList的subarrayList，对subarrayList的操作会对原arrayList造成影响，因为他们公用一个数组存储数据
     */
    public List<E> subList(int fromIndex, int toIndex) {
	subListRangeCheck(fromIndex, toIndex, size);// 数组越界检查
	return new SubList(this, 0, fromIndex, toIndex);
    }

    static void subListRangeCheck(int fromIndex, int toIndex, int size) {
	if (fromIndex < 0)
	    throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
	if (toIndex > size)
	    throw new IndexOutOfBoundsException("toIndex = " + toIndex);
	if (fromIndex > toIndex)
	    throw new IllegalArgumentException("fromIndex(" + fromIndex
		    + ") > toIndex(" + toIndex + ")");
    }

    private class SubList extends AbstractList<E> implements RandomAccess {
	private final AbstractList<E> parent;
	private final int parentOffset;// subArrayList
				       // 通过维护一个偏移量，调用原arrayList的方法操作实际存储的数组
	private final int offset;
	int size;

	SubList(AbstractList<E> parent, int offset, int fromIndex, int toIndex) {
	    this.parent = parent;
	    this.parentOffset = fromIndex;
	    this.offset = offset + fromIndex;
	    this.size = toIndex - fromIndex;
	    this.modCount = ArrayList.this.modCount;
	}

	public E set(int index, E e) {
	    rangeCheck(index);
	    checkForComodification();
	    E oldValue = ArrayList.this.elementData(offset + index);
	    ArrayList.this.elementData[offset + index] = e;
	    return oldValue;
	}

	public E get(int index) {
	    rangeCheck(index);
	    checkForComodification();
	    return ArrayList.this.elementData(offset + index);
	}

	public int size() {
	    checkForComodification();
	    return this.size;
	}

	public void add(int index, E e) {
	    rangeCheckForAdd(index);
	    checkForComodification();
	    parent.add(parentOffset + index, e);
	    this.modCount = parent.modCount;
	    this.size++;
	}

	public E remove(int index) {
	    rangeCheck(index);
	    checkForComodification();
	    E result = parent.remove(parentOffset + index);
	    this.modCount = parent.modCount;
	    this.size--;
	    return result;
	}

	protected void removeRange(int fromIndex, int toIndex) {
	    checkForComodification();
	    parent.removeRange(parentOffset + fromIndex, parentOffset + toIndex);
	    this.modCount = parent.modCount;
	    this.size -= toIndex - fromIndex;
	}

	public boolean addAll(Collection<? extends E> c) {
	    return addAll(this.size, c);
	}

	public boolean addAll(int index, Collection<? extends E> c) {
	    rangeCheckForAdd(index);
	    int cSize = c.size();
	    if (cSize == 0)
		return false;

	    checkForComodification();
	    parent.addAll(parentOffset + index, c);
	    this.modCount = parent.modCount;
	    this.size += cSize;
	    return true;
	}

	public Iterator<E> iterator() {
	    return listIterator();
	}

	public ListIterator<E> listIterator(final int index) {
	    checkForComodification();
	    rangeCheckForAdd(index);
	    final int offset = this.offset;

	    return new ListIterator<E>() {
		int cursor = index;
		int lastRet = -1;
		int expectedModCount = ArrayList.this.modCount;

		public boolean hasNext() {
		    return cursor != SubList.this.size;
		}

		@SuppressWarnings("unchecked")
		public E next() {
		    checkForComodification();
		    int i = cursor;
		    if (i >= SubList.this.size)
			throw new NoSuchElementException();
		    Object[] elementData = ArrayList.this.elementData;
		    if (offset + i >= elementData.length)
			throw new ConcurrentModificationException();
		    cursor = i + 1;
		    return (E) elementData[offset + (lastRet = i)];
		}

		public boolean hasPrevious() {
		    return cursor != 0;
		}

		@SuppressWarnings("unchecked")
		public E previous() {
		    checkForComodification();
		    int i = cursor - 1;
		    if (i < 0)
			throw new NoSuchElementException();
		    Object[] elementData = ArrayList.this.elementData;
		    if (offset + i >= elementData.length)
			throw new ConcurrentModificationException();
		    cursor = i;
		    return (E) elementData[offset + (lastRet = i)];
		}

		public int nextIndex() {
		    return cursor;
		}

		public int previousIndex() {
		    return cursor - 1;
		}

		public void remove() {
		    if (lastRet < 0)
			throw new IllegalStateException();
		    checkForComodification();

		    try {
			SubList.this.remove(lastRet);
			cursor = lastRet;
			lastRet = -1;
			expectedModCount = ArrayList.this.modCount;
		    } catch (IndexOutOfBoundsException ex) {
			throw new ConcurrentModificationException();
		    }
		}

		public void set(E e) {
		    if (lastRet < 0)
			throw new IllegalStateException();
		    checkForComodification();

		    try {
			ArrayList.this.set(offset + lastRet, e);
		    } catch (IndexOutOfBoundsException ex) {
			throw new ConcurrentModificationException();
		    }
		}

		public void add(E e) {
		    checkForComodification();

		    try {
			int i = cursor;
			SubList.this.add(i, e);
			cursor = i + 1;
			lastRet = -1;
			expectedModCount = ArrayList.this.modCount;
		    } catch (IndexOutOfBoundsException ex) {
			throw new ConcurrentModificationException();
		    }
		}

		final void checkForComodification() {
		    if (expectedModCount != ArrayList.this.modCount)
			throw new ConcurrentModificationException();
		}
	    };
	}

	public List<E> subList(int fromIndex, int toIndex) {
	    subListRangeCheck(fromIndex, toIndex, size);
	    return new SubList(this, offset, fromIndex, toIndex);
	}

	private void rangeCheck(int index) {
	    if (index < 0 || index >= this.size)
		throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	}

	private void rangeCheckForAdd(int index) {
	    if (index < 0 || index > this.size)
		throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	}

	private String outOfBoundsMsg(int index) {
	    return "Index: " + index + ", Size: " + this.size;
	}

	private void checkForComodification() {
	    if (ArrayList.this.modCount != this.modCount)
		throw new ConcurrentModificationException();
	}
    }
}