ArrayList源码解析

ArrayList源码解析

---

集合是java中非常重要且基础的内容，集合的作用就是以一定的方式来组织、存储数据。ArrayList是常用的结合之一。

集合特点

1. 可以允许空
2. 可以有重复数据
3. 集合内容是有序的
4. 线程不完全的

数据结构

ArrayList底层是动态数组方式实现的，数据结构就是数组，之所以叫动态数据，是因为数组的容量是不固定的，add、remove操作可能会
引起数组大小容量的变化.我们先来看看源码，由于jdk1.6跟jdk1.7源码有些变化,这里以jdk1.7为例,来看看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 = {};

    /**
     * 内部一个Object类数组，存储元素，不用序列化
     * 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 == EMPTY_ELEMENTDATA will be expanded to
     * DEFAULT_CAPACITY when the first element is added.
     */
    private transient Object[] elementData;

    /**
     * The size of the ArrayList (the number of elements it contains).
     * 存入元素的大小
     * @serial
     */
    private int size;

    /**
     * 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) {
        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. 无参构造实例，初始大小为0，元素集合默认为空实例。
     */
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

ArrayList实现了List接口，而List又实现了Collection集合接口。ArrayList是基于动态数组的一个实现，elementData就是底层的数组。
DEFAULT_CAPACITY是默认的初始化容量。再看看构造器：

构造器

声明一个简单的ArrayList实现：

List arrayList = new ArrayList<>();

ArrayList默认提供了无参、有参构造器,有参构造器可以自定义集合的初始化容量。

a.无参构造器

public ArrayList() {
    super();
    this.elementData = EMPTY_ELEMENTDATA;
}

默认给elementData初始化了一个空的数组,我们再来对比一下jdk1.6的实现：

public ArrayList() {
    this(10);
}

会发现jdk1.6中ArrayList的无参构造器会默认初始化数组的容量为10,而1.7默认初始化数组容量为0,但是在add方法的内部可以看到，添加数据之前,会给数组扩容，初始容量也是10,后面会详细介绍add方法。
jdk1.7的这一变化个人觉得是优化了内存空间,一开始就给数组初始化容量,如果定义的集合没有被使用,不仅占用内存，而且会增加GC的负担,相反1.7中使用了延迟初始化的策略，在需要使用的时候再自动分配数组容量更能减少内存的开销，也很符合ArrayList动态扩容的特性。
由于ArrayList的数组是保存在elementData这个私有成员变量里面,这里我们可以利用反射原理检测一下ArrayList的初始容量：

public class App {
    public int getArrayListArraySize(List<?> list) {
        Class<?> clazz = list.getClass();
        int size = 0;
        try {
            Field field = clazz.getDeclaredField("elementData");
            field.setAccessible(true);
            Object[] elementData = (Object[]) field.get(list);
            size = elementData.length;
        } catch (Exception e) {}
        return size;

    }
    public static void main( String[] args ){
        App app = new App();
        List arrayList = new ArrayList<>();
        List arrayList1 = new ArrayList<>(12);
        System.out.println("arrayList初始容量：" +app.getArrayListArraySize(arrayList));
        System.out.println("arrayList1初始容量：" +app.getArrayListArraySize(arrayList1));

        arrayList.add("123");
        System.out.println("arrayList添加元素之后容量：" +app.getArrayListArraySize(arrayList));
    }
}

可以看到结果：
arrayList初始容量：0
arrayList1初始容量：12
arrayList添加元素之后容量：10

这里我使用的是jdk1.7,ArrayList由于默认初始化容量是0,但是调用add方法之后会自动扩容，容量会变成10。大家可以自行试试1.6,来验证一下。

b. 有参构造器

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

有参构造器会根据传入的参数大小初始化数组elementData的容量，分配内存空间。

add方法

add方法是集合中用来添加元素的方法,使用也很简单：

List arrayList = new ArrayList<>();
    arrayList.add("123");

我们先来看看它的方法实现：

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

可以看到调用add方法之前先调用了ensureCapacityInternal方法,我们再看看这个方法的实现：

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

由于数组elementData的初始化容量是空的,这里会进入if内部执行minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);这段代码,
我们知道size默认值为0,这里minCapacity结果为1,DEFAULT_CAPACITY默认为10,所以这里返回minCapacity=10。再往下看看ensureExplicitCapacity方法实现：

private void ensureCapacityInternal(int minCapacity) {
        modCount++;//定义于ArrayList的父类AbstractList，用于存储结构修改次数
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }  
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//新容量扩大到原容量的1.5倍，右移一位相关于原数值除以2。
        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);
    }

这个方法的作用就是用来给数组扩容用的,大概意思就是向ArrayList添加对象时，原对象数目加1如果大于原底层数组elementData长度，则以适当长度新
建一个原数组的拷贝，并修改原数组,指向这个新建数组,原数组会被GC回收掉。

    这里new数组的时候是要额外申请内存空间的,还有旧数组的回收,所以事先定义好数组的size,可以节省空间和时间。但是一次性扩容扩得太大，必然造成内存空间的浪费.
    如果一次性扩容扩得不够，那么下一次扩容的操作必然比较快地会到来，这会降低程序运行效率,所以扩容扩多少，是JDK开发人员在时间、空间上做的一个权衡,提供出来的一个比较合理的数值。

remove方法

ArrayList提供了两种remove方法：

E remove(int index);
boolean remove(Object o);

两种方法的实现都差不多,都是调用了同一个方法：

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
    }

这个方法主要做了两件事情：

1、把指定元素后面位置的所有元素，利用System.arraycopy方法整体向前移动一个位置
2、最后一个空出来的位置的元素置为null，这样让gc可以去回收它

ArrayList优缺点

优点：由于ArrayList底层是基于数组实现的,随机访问速度很快

缺点：添加和删除元素的效率比较低,由于添加和删除元素时涉及到数组中大量元素的拷贝,性能比较差。

线程不安全

ArrayList在多线程场合是线程不安全的，而Vector是ArrayList的线程安全版本，它的方法都加了synchronized同步锁。如果要让ArrayList实现线程安全，也可以使用现成的：

List synchronizedList = Collections.synchronizedList(arrayList);
synchronizedList.add(123);

利用Collections.synchronizedList(arrayList)可以把ArrayList变成线程安全的。