ArrayList<E>源码学习笔记

成员变量：这个类里面有两个私有成员变量：

private transient Object[] elementData;//ArrayList底层维护的是一个Object类型的数组，这样就是使得该集合可以存放任何类型的数据，而这些元素就存放着这个数组中

private int size;//该变量用于记录该集合中所包含元素的个数，而不是底层数组的长度，每增加或删除一个元素，size的值就会相应地增加或减小

构造方法：这个类有三个构造方法：

public ArrayList(int initialCapacity)//构建一个带有初始容量的ArrayList集合，该方法会先判断给定数值是否<0，然后才会创建数组，这种每次操作集合之前先判断的做法在Java源码中普遍存在。源码如下：

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

public ArrayList()

public ArrayList() {this(10);    }

public ArrayList(Collection<? extends E> c)//以一个集合为参数创建一个ArrayList集合

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

实用方法：

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

作用：整理集合的容量，使得集合的容量值与当前集合中所包含的元素数相等，即capacity = size。这样做可以节约内存空间。

modCount变量是该类的父类AbstractList<E>中的成员变量，用于记录对集合接口进行操作的次数。

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。这个方法是contains(Object o)方法的基础，不再赘述。

   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。效果跟indexOf(Object o)方法正好相反。

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

作用：以合适的序列（一般是从第一个元素到最后一个元素）返回该集合对应的Object类型数组。

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

作用：以合适的序列（一般是从第一个元素到最后一个元素）返回该集合对应的指定类型数组。相当于返回该集合包含的元素所对应的类型数组（转型后的数组）。

 public E get(int index) {RangeCheck(index);return (E) elementData[index];    }

作用：返回指定数组下标上的元素，操作之前先判断下标是否越界。

    public E set(int index, E element) {RangeCheck(index);E oldValue = (E) elementData[index];elementData[index] = element;return oldValue;    }

作用：用指定元素替换指定下标位置上的元素，并返回被替换的元素。操作之前先判断下标是否越界。

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

作用：在集合的最后添加一个元素，操作之前先确保数组的容量，若容量到达预警值则对数组进行扩容。

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

作用：将指定元素插入到数组的指定位置。先对下标进行判断，然后确保数组的容量，最后进行插入操作。注意：该操作会对数组进行复制，首相将原数组指定位置及以后的元素依次往后挪一个位置，创建空出指定位置的新数组，然后将指定元素插入到该位置。该操作的成本比较高。

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

作用：删除指定的元素。注：该方法只会删除数组中第一次出现指定元素位置上的元素。跟上面的方法一样，这个方法也会修改创建一个将指定位置删除的新数组。该操作的成本比较高。

    public void clear() {modCount++;// Let gc do its workfor (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;ensureCapacity(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) {if (index > size || index < 0)    throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);Object[] a = c.toArray();int numNew = a.length;ensureCapacity(size + numNew);  // Increments modCountint 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;    }

作用：将一个集合中的所有元素添加到指定该集合的指定位置，原集合指定位置及其以后的元素依次往后挪一个位置。该操作的成本比较高。

2016年9月7日  18:06