Java8——ArrayList源码详解

ArrayList

从这段注释中，我们可以得知 ArrayList 是一个动态数组，实现了 List 接口以及 list相关的所有方法，它允许所有元素的插入，包括 null。另外，ArrayList 和 Vector 除了线程不同步之外，大致相等。

ArrayList属性

private static final long serialVersionUID = 8683452581122892189L;
	//默认初始容量
    private static final int DEFAULT_CAPACITY = 10;
     // 空数组常量
    private static final Object[] EMPTY_ELEMENTDATA = {};
	//默认的空数组常量
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
	//存放元素的数组，ArrayList底层实现的就是一个Object数组
    transient Object[] elementData; 
	//数组中包含的元素个数
    private int size;
    //数组的最大上限
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

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是一个大小为0的空数组，当我们指定了初始大小后，elementData的初始大小就变成了我们所指定的大小。

get方法

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

        return elementData(index);
    }
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

ArrayList采用数组结构存储，首先判断是否越界，然后就可以通过数组下标来获取元素了。时间复杂度为O（1）

add方法

public boolean add(E e) {
 ensureCapacityInternal(size + 1); // Increments modCou
nt!!
 elementData[size++] = e;
 return true; }
public void add(int index, E element) {
 rangeCheckForAdd(index);
 ensureCapacityInternal(size + 1); // Increments modCou
nt!!
 //调用一个 native 的复制方法，把 index 位置开始的元素都往后挪一位
 System.arraycopy(elementData, index, elementData, inde
x + 1, size - index);
 elementData[index] = element;
 size++;
}

private void ensureCapacityInternal(int minCapacity) {
 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
 minCapacity = Math.max(DEFAULT_CAPACITY, minCapacit
y);
 }
 ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
 modCount++;
 if (minCapacity - elementData.length > 0)
 grow(minCapacity);
}

ArrayList 的 add 方法也很好理解，在插入元素之前，它会先检查是否需要扩容，然后再把元素添加到数组中最后一个元素的后面。在 ensureCapacityInternal 方法中，我们可以看见，如果当 elementData 为空数组时，它会使用默认的大小去扩容。所以
说，通过无参构造方法来创建 ArrayList 时，它的大小其实是为 0 的，只有在使用到的时候，才会通过 grow 方法去创建一个大小为 10 的数组。
第一个 add 方法的复杂度为 O(1)，虽然有时候会涉及到扩容的操作，但是扩容的次数是非常少的，所以这一部分的时间可以忽略不计。
如果使用的是带指定下标的 add方法，则复杂度为 O(n)，因为涉及到对数组中元素的移动，这一操作是非常耗时的。

set方法

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

set 方法的作用是把下标为 index 的元素替换成 element，跟 get 非常类似，时间复杂度度为 O(1)。

remove 方法

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 wo
rk
 return oldValue;
}

remove 方法与 add 带指定下标的方法非常类似，也是调用系统的 arraycopy 方法来移动元素，时间复杂度为 O(n)。

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 wi
n:
 elementData = Arrays.copyOf(elementData, newCapacity);
}

grow 方法是在数组进行扩容的时候用到的，从中我们可以看见，ArrayList 每次扩容都是扩 1.5 倍，然后调用 Arrays 类的 copyOf 方法，把元素重新拷贝到一个新的数组中去。

Size方法

public int size() {
 return size;
}

size 方法非常简单，它是直接返回 size 的值，也就是返回数组中元素的个数，时间复杂度为 O(1)。返回的并不是数组的实际大小。

IndexOf 和lastIndexOf

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; }
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 方法的作用是返回第一个等于给定元素的值的下标。它是通过遍历比较数组中每个元素的值来查找的，所以它的时间复杂度是 O(n)。lastIndexOf 的原理跟 indexOf 一样，而它仅仅是从后往前找起罢了。

总结

1、ArrayList创建时的大小为0，当加入第一个匀速时，进行第一次扩容时，默认容量大小为10。
2、ArrayList每次扩容都以当前数组大小的1.5倍去扩容