ArrayList使用及原理

之前面试时，经常被问到ArrayList的原理，今天整理了一些ArrayList的使用原理和必问的知识点。

ArrayList的继承关系

定义一个ArrayList的方法

ArrayList的三个构造函数：

1.无参

   //默认创建一个ArrayList集合
    ArrayList<String> arrayList1 = new ArrayList<>();

2.参数为整数

   //创建一个初始长度为20的ArrayList集合
    ArrayList<String> arrayList2 = new ArrayList<>(20);

3.参数为集合

//将其它类型的集合转化为ArrayList
    ArrayList<String> arrayList3 = new ArrayList<>(new HashSet());

我们读ArrayList的构造函数源码之前，先看看ArrayList的属性情况：

 1     /**
 2      * Default initial capacity.
 3      */
 4     private static final int DEFAULT_CAPACITY = 10;
 5
 6     /**
 7      * Shared empty array instance used for empty instances.
 8      */
 9     private static final Object[] EMPTY_ELEMENTDATA = {};
10
11     /**
12      * Shared empty array instance used for default sized empty instances. We
13      * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
14      * first element is added.
15      */
16     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
17
18     /**
19      * The array buffer into which the elements of the ArrayList are stored.
20      * The capacity of the ArrayList is the length of this array buffer. Any
21      * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
22      * will be expanded to DEFAULT_CAPACITY when the first element is added.
23      */
24     transient Object[] elementData; // non-private to simplify nested class access
25
26     /**
27      * The size of the ArrayList (the number of elements it contains).
28      *
29      * @serial
30      */
31     private int size;

可以看到，ArrayList是非线程安全的容器，底层实现是Object[],数据会添加到ArrayList的elementData数组中，而且默认容量DEFAULT_CAPACITY=10

。但其实在jdk1.7之后，ArrayList的默认容量就是0了，而且DEFAULT_CAPACITY在扩容的过程中才会用到。

我们再看看ArrayList的三种构造函数。

ArrayList有参构造函数-参数类型为整型

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

可以看到，如果传入正整数，则elementData数组容量初始化为initiaCapacity；如果传入0，则elementData数组赋值为一个空数组。可能有读者发现

ArrayList类中有两个属性定义为空数组。

为什么ArrayList会定义两个空数组？

注释中给出了官方的解释(下有翻译)

 /**
     * 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 = {};

简而言之，EMPTY_ELEMENTDATA与DEFAULTCAPACITY_EMPTY_ELEMENTDATA在功能上有不同的意义，前者是单纯用于赋值为空数组，

后者是给elementData数组初始化的。

ArrayList有参构造函数-参数类型为集合类

 public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

可以看到，只要实现了Collection的集合类，都会调用toArray()将集合类中的数组赋给elementData。而且toArray()返回的数组类型不是Object[]类型时

...etc,toArray()返回的数组类型为什么会不是Object[]类型？举个栗子：

public class Test<E> extends ArrayList{
 @Override
public Integer[] toArray() {
    return new Integer[] {0,23};
}
    public static void main(String[] args) {
    Object[] elementData = new Test<Integer>().toArray();
    System.out.println(elementData.getClass());
    System.out.println(Object[].class);
    System.out.println(elementData.getClass()==Object[].class);
    }
}

运行结果为：

好，我们接着说当toArray()返回的数组类型不是Object[]类型时，会调用Arrays.copyOf()将原数组拷贝到新数组去，而且类型还可以定义为Object类：

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

ArrayList无参构造函数

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

在这里，我们可以看到，jdk1.8以后ArrayList的默认容量为0.

如果ArrayList的默认容量为0，还可以添加数组吗？

当然可以，通过扩容机制可以扩充ArrayList的容量：

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

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

在这里我们可以看到，如果elementData数组依然为DEFAULTCAPACITY_EMPTY_ELEMENTDATA(即初始状态)，则通过

ensureExplicitCapacity()方法将ArrayList容量扩充为10(DEFAULT_CAPACITY)。

为什么无参构造函数对ArrayList容量的初始化改变了呢？

虽然jdk1.8中的ArrayList默认容量为0，但在jdk1.6的无参构造函数的ArrayList默认容量为10：

public ArrayList(){
this(10);
}

个人认为，jdk1.8中延迟初始化ArrayList的实际容量，应该是考虑如果一开始就初始化为10，那么大小为1o的数组中存的全部是null，这种数组多了也会占用大量的

空间，所以这是为了节省不必要浪费的空间，体现了懒加载的思想。

怎样使用ArrayList？

既然我们已经知道了怎么去定义一个ArrayList，接下来就是要使用ArrayList了，而ArrayList提供了常见的方法有：add、addAll、set、get、remove、size、isEmpty等。

因为ArrayList的一些方法会涉及到数据位置的变换，为了更直观的感受这些变化，在这里我们来举个栗子：

    ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("吕布");
        arrayList.add("貂蝉");
        arrayList.add("董卓");
        arrayList.add("刘备");
        arrayList.add("赵云");

也就是说，elementData数组中有这些数据：

如果在这些人物中加入”曹操“,我们来看看这个操作在源码中是怎么样的过程：

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

首先，会先通过ensureCapacityInternal(size+1)检查elementData数组的容量是否充足，然后在将数据放入数组中，我们来看看ArrayList是怎么进行容量检查的。

ensureCapacityInternal()

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

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

在这个方法中，确定elementData数组是不是空数组，如果是的话，将形参minCapacity赋值为10(DEFAULT_CAPACITY),然后进入ensureExplicitCapacity()方法。

  private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

此方法中的modCount变量是从AbstractList继承下来的，用于记录对ArrayList的对象操作的次数：

private transient int modCount=0；

可以看到当形参minCapacity的数值比当前的elementData数组的长度大，则要调用grow()方法进行扩容操作。

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }

可以看到，扩容规则为“数组当前的容量+（数组当前的容量/2）”，即扩容后的数组容量为之前数组容量的1.5倍。当然，如果超过了最大值，在hugeCapacity（）方法

中会对其进行处理。

 private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

如果形参minCapacity大于MAX_ARRAY_SIZE,则赋值为interger.MAX_VALUE,实际上MAX_ARRAY_SIZE与Integer.MAX_VALUE相差8.

回到之前的例子中，elementData数组的容量为10，而数组中的数据只有6个，所以“曹操”的加入并不会引起扩容，此时elementData数组中的数据如下:

与add()类似的方法还有：

add(0,"马超")

此方法将数组中的元素各自往后移动一位之后，再将“马超”放在第一个位置上：

addAll(1,list..."张飞"，“马谡”，“黄忠”)

将"张飞"，“马谡”，“黄忠”放到“吕布”之后，那么数组第二个位置后的元素都需要往后移动三位，而且明显看到数组的容量已经不够了，按规则数组会扩容到16.

如果需要在既定位置安插数据，则需要通过rangeCheckForAdd()方法判断数组是否越界。

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

set(int index，E element)

在add()方法中，如果要在数组中（除了数组末尾）安插一个数据，需要将安插位置之后的数据往后移动一位，但如果需要替换数组某个位置的数据，则需要找到对应位置，替换

元素即可。

 public E set(int index, E element) {
        rangeCheck(index);

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

在set()方法执行过程中，需要进行rangeCheck()数组范围检查之后，再将元数据取出用于返回，并在该数组位置替换新数据，如将“马超”替换为“马良”：

ArrayList中的get()方法获取数据的方法也很简单，只需要先判断传入的数组下标是否越界，并通过下标查找，转换类型即可。

 public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

其中的elementData()方法的实现如下：

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

remove（int index）和remove（Object o）

ArrayList有两种删除方式，一种是通过下标选择删除的元素，另一个是通过值对象删除元素。我们来了解一下前者：

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

通过下标选择删除的元素的remove（int index）方法中，在删除元素之前，需要先对下标进行范围检查rangeCheck()，然后在计算出需要移动的元素个数，

通过arraycopy()即数组复制方式，将既定位置之后的元素都向前移动一位，最后在设置elementData[size-1]为null，使GC回收对其起作用。

接下来我们来看后者：

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

通过值对象删除元素的remove(Object o)方法中，程序将null单独进行处理，因为null是一种状态，不属于任何类型的值。再选中了既定值对象对应的下标之后，删除操作

将会在fastRemove()方法中进行，而fastRemove()方法中的操作过程就跟remove(int index)类似，

在看一下ArrayList的其它方法

--size():用于获取集合的长度。

--isEmpty():用于判断ArrayList是否为空。

--contains():用于判读ArrayList是否包含某个元素。

--clear():从列表删除所有元素