ArrayList源码解析（一）

以下分析均以jdk1.8为准。

首先来看一下ArrayList的继承体系：

ArrayList继承自AbstractList，实现了 List, Cloneable, Serializable, RandomAccess接口。这一点从源码上也可以看到

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

先来看看ArrayList的内部成员概览吧。

从上图看到ArrayList内部，有7个成员变量，4个内部类。

  private static final long serialVersionUID = 8683452581122892189L;   //用作序列化，暂不管
//默认初始化容量为10
    private static final int DEFAULT_CAPACITY = 10;

//空的对象数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

//默认的空对象数组,调用ArrayList的无参构造函数时创建的对象数组。                                   
    private static final Object[] EFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// 实际存放List元素的对象数组缓存变量。ArrayList的容量就是这个数组的长度(length)。
    transient Object[] elementData;

//ArrayList的大小，实际所拥有元素的数量。
    private int size;

//最大数组容量，大约为2147483639。20多亿,绝对够用了
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

注意到elementData被transient所修饰。
有个关键字需要解释：transient。

Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。
tansient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

带默认初始化容量的构造函数 ArrayList ( int initialCapacity )

public ArrayList(int initialCapacity) {
    //如果初始化容量大于0
    if (initialCapacity > 0) {
    //直接new一个该大小的对象数组赋值给elementData
           this.elementData = new Object[initialCapacity];
       } else if (initialCapacity == 0) {  //如果初始化容量为0
       //直接将空数组赋值给elementData
           this.elementData = EMPTY_ELEMENTDATA;
       } else {//初始化参数为负数，抛出异常，非法参数
            throw new IllegalArgumentException("Illegal Capacity:"+initialCapacity);
        }
    }

无参构造函数ArrayList( )

 public ArrayList() {
 //将空数组赋值给elementData，这时候容量还是0，之后添加元素时会扩容
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

通过指定的集合对象c来构造ArrayList( Collection< ? extends E  > c )

按照集合对象的迭代器返回的元素顺序进行填充。如果集合对象为null，抛出NullPointerException异常

 public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();//将集合c转换为对象数组再赋值给elementData。不同的Collection实现有各自不同的toArray()方法。
        if ((size = elementData.length) != 0) {//elementData大小不为0
            if (elementData.getClass() != Object[].class) //c.toArray()返回的不一定是Object[]，这里进行一个类型转换
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            //如果c.toArray()为空数组，elementData默认为空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

修整容量为当前实际大小: trimTosize( )。

（容量一般会由于扩容的原因大于实际大小，例如添加了一个元素的ArrayList实例容量为10，大小为1，该操作就是将容量缩小为1），该操作可以减少ArrayList的内存使用。但执行完trimTosize()方法之后如果再添加元素，还是会进行扩容。所以除非知道在之后不会再添加元素，否则调用trimTosize()方法没有意义。

public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size); //利用Arrays.copyOf()方法对数组进行复制重组
        }
    }

当前元素数量size( )

public int size() {
        return size;
    }

获取对象索引：indexOf( Object o )

返回对象第一次出现时的索引，如果没有该对象，返回-1。

 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是否为null,如果是null，for循环遍历elementData，如果找到某个元素为null，则返回该元素的索引值。如果o不为null，for循环遍历elementData，通过equals判断如果有某个元素等于指定对象o,则返回该元素的索引。如果找不到该对象，返回-1。
这里通过对象的equals方法判断元素是否为某个对象。

获取最后一次出现的索引 lastIndexOf( Object o )

/**
     * Returns the index of the last occurrence of the specified element
     * in this list, or -1 if this list does not contain the element.
     */

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

逻辑跟indexOf类似，只不过从数组末尾向前遍历。

是否包含某元素：contains(&nsbsp;Object o )

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

通过判断对象索引是否>=0。

将list转换为对象数组 toArray()

新对象数组的长度为list的size

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

返回的是Object[]，并不是对应的泛型数组，而且也不能强制转换为对应的泛型数组。如果需要转化为对于的泛型数组，可以参考 public < T > T[] toArray(T[] a) 方法。
举例说明:

 ArrayList<Integer> list = new ArrayList<Integer>();
        list.addAll(Arrays.asList(1,2,3,4,5,6,7,8,9));
        Object[] objects = list.toArray();
        Integer[] s = (Integer[])objects;  //抛出异常:
        //java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;

返回的数组是重现分配了内存的，跟原来的list已经脱离，相互不影响

将list转换为对应的泛型数组 toArray(T[] a)

/**    
     * @return an array containing the elements of the list
     * @throws ArrayStoreException if the runtime type of the specified array is
     *  not a supertype of the runtime type of every element in this list
//如果a的类型不是list中所有元素的超类，那么抛出ArrayStoreException异常。
public <T> T[] toArray(T[] a) {
        if (a.length < size)
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

从源码上看，当a.length < size时，创建一个新的数组并将elementData的数据复制到新数组中，返回新数组。这没有任何问题。

需要注意的是：当a.length>size时，将elementData的数据复制到a,将a[size]置为null。虽然不明白为什么要这么做，但需要注意。最终返回a。例如我写了下面一个测试例子，会导致一些预料之外的事情。

    List<Integer> list = new ArrayList<Integer>();
    list.addAll(Arrays.asList(1,2,3,4,5,6,7,8,9));
    Integer[] intArr = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5};  // intArr的长度大于list的size
    Integer[] result = list.toArray(intArr);
    for (int i = 0; i < intArr.length; i++) {
        System.out.print(intArr[i]+" ");  //输出1 2 3 4 5 6 7 8 9 null 4 4 5 5 5 . 
       //由于intArr[size] = null。 size为9的数据被置空了，这显然不是我们需要的。
    }
    //而且需要注意的是：intArr和返回值result指向了同一个数组对象，修改其中一个会影响另一个
    System.out.println();
    for (int i = 0; i < result.length; i++) {
        System.out.print(result [i]+" "); //输出1 2 3 4 5 6 7 8 9 null 4 4 5 5 5
    }
    System.out.println();
    result[0] = 0; result[1] = 0; //修改result,也会同步影响intArr。
    for (int i = 0; i < intArr.length; i++) {
        System.out.print(intArr[i]+" "); //输出0 0 3 4 5 6 7 8 9 null 4 4 5 5 5
    }

对此，我的建议是：传递给toArray(T[] a)的数组a为空数组（没有填充数据），只要指明相应的类型就可以。Integer[] intArr = list.toArray(new Integer[]{})

通过索引获取对象 E get(int index)

public E get(int index) {
     if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

     return (E)elementData(index);
    }

设置指定索引的值

 public E set(int index, E element) {
      if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

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

清空list: clear()

public void clear() {
        modCount++;

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

        size = 0;
    }

clear()只是将元素都置为null，将size设置为0。但不会修改容量。