【集合框架】JDK1.8源码分析之ArrayList详解(一)

一. 从ArrayList字表面推测

ArrayList类的命名是由Array和List单词组合而成，Array的中文意思是数组，List的中文意思是列表。从ArrayList字表面推测,ArrayList类是否有数组和列表的特征？那么，这些特征这在ArrayList类中又是怎么体现的？

ArrayList源码分析

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

从上面的代码可知道，以下几点

继承了AbstractList类，实现了List，意味着ArrayList是一个数组队列，提供了诸如增删改查、遍历等功能。
实现了RandomAccess接口，意味着ArrayList提供了随机访问的功能。RandomAccess接口在Java中是用来被List实现，用来提供快速访问功能的。在ArrayList中，即我们可以通过元素的序号快速获取元素对象。
实现了Cloneable接口，意味着ArrayList实现了clone()函数，能被克隆。
实现了java.io.Serializable接口，意味着ArrayList能够通过序列化进行传输。

ArrayList的属性

    /**     * Default initial capacity.     */    private static final int DEFAULT_CAPACITY = 10;    /**     * Shared empty array instance used for empty instances.     */    private static final Object[] EMPTY_ELEMENTDATA = {};    /**     * Shared empty array instance used for default sized empty instances. We     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when     * first element is added.     */    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};    /**     * The array buffer into which the elements of the ArrayList are stored.     * The capacity of the ArrayList is the length of this array buffer. Any     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA     * will be expanded to DEFAULT_CAPACITY when the first element is added.     */    transient Object[] elementData; // non-private to simplify nested class access    /**     * The size of the ArrayList (the number of elements it contains).     *     * @serial     */    private int size;

DEFAULT_CAPACITY ：默认容量大小为10。
EMPTY_ELEMENTDATA ：用于Constructs有参数传入，如果参数等于零，则使用该属性。
DEFAULTCAPACITY_EMPTY_ELEMENTDATA ：用于Constructs无参数传入默认大小为10（具体运用于add中），使用使用该属性。
size ：当前容量大小

## 构造分析
### 有参数构造Method
传入initialCapacity参数，如果参数大于零，创建一个大小为initialCapacity的数组
/** * Constructs an empty list with the specified initial capacity. * * @param initialCapacity the initial capacity of the list * @throws IllegalArgumentException if the specified initial capacity * is negative */ public ArrayList(int initialCapacity) { if (initialCapacity > 0) { //new一个大小为initialCapacity的数组 this.elementData = new Object[initialCapacity]; } else if (initialCapacity == 0) { this.elementData = EMPTY_ELEMENTDATA; } else { throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); } }

无参数构造Method

里面只有一个操作就是把 elementData 设置为 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 这个空数组。

// 无参的构造函数，传入一个空数组  这时候会创建一个大小为10的数组，具体操作在 add 中 public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }

增删查改Method

add Method

这个方法首先调用了 ensureCapacityInternal() 这个方法里面就判断了当前的 elementData 是否等于 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 如果是的话，就把数组的大小设置为 10 然后进行扩容操作,这里刚好解释了为什么采用无参构造的List 的大小是 10 ，这里扩容操作调用的方法是 ensureExplicitCapacity 里面就干了一件事如果用户指定的大小大于当前长度就扩容，扩容的方法采用了 Arrays.copy 方法，这个方法实现原理是 new 出一个新的数组，然后调用 System.arraycopy 拷贝数组，最后返回新的数组。

public boolean add(E e) { // 当调用了无参构造，设置大小为10 ensureCapacityInternal(size + 1);  // Increments modCount elementData[size++] = e; return true;}  private void ensureCapacityInternal(int minCapacity) { // 如果当前数组是默认空数组就设置为 10和 size+1中的最小值 // 这也就是说为什么说无参构造 new 的数组大小是 10 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); }   ensureExplicitCapacity(minCapacity);}  private void ensureExplicitCapacity(int minCapacity) { modCount++;   // 若用户指定的最小容量 > 最小扩充容量，则以用户指定的为准，否则还是 10 if (minCapacity - elementData.length > 0) grow(minCapacity);}  private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; // 1.5倍增长 int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0) newCapacity = minCapacity; 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);}

Remove Method

通过index知道位置，然后index位置的值被index+1位置的值往前覆盖，覆盖的次数为size – index – 1

/**     * Removes the element at the specified position in this list.     * Shifts any subsequent elements to the left (subtracts one from their     * indices).     *     * @param index the index of the element to be removed     * @return the element that was removed from the list     * @throws IndexOutOfBoundsException {@inheritDoc}     */    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; // clear to let GC do its work        return oldValue;    }

get Method

通过index 来访问元素

public E get(int index) {            //检测范围            rangeCheck(index);            checkForComodification();            return ArrayList.this.elementData(offset + index);        }

set Method

通过index知道要修改的元素并替换了

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