【Java】ArrayList 的实现原理

一、概述

　　本例使用的是JDK8.

　　一上来，先来看看源码中的这一段注释，我们可以从中提取到一些关键信息:

　　Resizable-array implementation of the List interface. Implements all optional list operations, and permits all elements, including null. In addition to implementing the List interface, this class provides methods to manipulate the size of the array that is used internally to store the list. (This class is roughly equivalent to Vector, except that it is unsynchronized.)

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

　　ArrayList 使用动态数组存储数据

二、结构图

　　

三、属性

//默认容量的大小
private static final int DEFAULT_CAPACITY = 10;
//空数组常量
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认的空数组常量
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMEN TDATA = {};
//存放元素的数组，从这可以发现 ArrayList 的底层实现就是一个 Object数组
transient Object[] elementData;
//数组中包含的元素个数 private int size;
//数组的最大上限
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

　　ArrayList 的属性非常少，就只有这些。其中最重要的莫过于 elementData 了，ArrayList 所有的方法都是建立在 elementData 之上。接下来，我们就来看一下一些主要的方法 吧。

四、方法

1、构造方法

　　ArrayList 提供了三种方式的构造器，可以构造一个大小为 0 的空数组的空列表、构造 一个指定初始容量的空列表以及构造一个包含指定 collection 的元素的列表，这些元素按照 该 collection 的迭代器返回它们的顺序排列的。

// 构造一个大小为 0 的空数组的空列表
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}


// 构造 一个指定初始容量的空列表
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);
    }
}


// 构造一个包含指定 collection 的元素的列表
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;
    }
}　　

 　　从构造方法中我们可以看见，默认情况下，elementData 是一个大小为 0 的空数组，

　　当我们指定了初始大小的时候，elementData 的初始大小就变成了我们所指定的初始 大小了。

2、存储方法

 　　ArrayList 提供了 set(int index, E element)、add(E e)、add(int index, E element)、 addAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c)这些添加 元素的方法。

　　下面我们一一介绍:

// 用指定的元素替代此列表中指定位置上的元素，并返回以前位于该位置上的元素。
public E set(int index, E element) {
    rangeCheck(index);

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


// 将指定的元素添加到此列表的尾部。
public boolean add(E e) {
    // 如果数组长度不足，将进行扩容。
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}


// 将指定的元素插入此列表中的指定位置。
// 如果当前位置有元素，则向右移动当前位于该位置的元素以及所有后续元素(将其索引加 1)。
public void add(int index, E element) {
    rangeCheckForAdd(index);

    // 如果数组长度不足，将进行扩容。
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 将 elementData中从Index位置开始、长度为size-index的元素，
    // 拷贝到从下标为 index+1 位置开始的新的 elementData 数组中。
    // 调用一个 native 的复制方法，把 index 位置开始的元素都往后挪一位
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}


// 按照指定collection的迭代器所返回的元素顺序，将该collection中的所有元素添加到此 列表的尾部。
public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

// 从指定的位置开始，将指定collection中的所有元素插入到此列表中。
public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);

    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

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

 　　ArrayList 的 add 方法也很好理解，在插入元素之前，它会先检查是否需要扩容，然 后再把元素添加到数组中最后一个元素的后面。在 ensureCapacityInternal 方法中， 我们可以看见，如果当 elementData 为空数组时，它会使用默认的大小去扩容。所以 说，通过无参构造方法来创建 ArrayList 时，它的大小其实是为 0 的，只有在使用到 的时候，才会通过 grow 方法去创建一个大小为 10 的数组。

　　第一个 add 方法的复杂度为 O(1)，虽然有时候会涉及到扩容的操作，但是扩容的次 数是非常少的，所以这一部分的时间可以忽略不计。如果使用的是带指定下标的 add 方法，则复杂度为 O(n)，因为涉及到对数组中元素的移动，这一操作是非常耗时的。

3、调整数组容量

　　从上面介绍的向 ArrayList 中存储元素的代码中，我们看到，每当向数组中添加元素时， 都要去检查添加后元素的个数是否会超出当前数组的长度，如果超出，数组将会进行扩容， 以满足添加数据的需求。数组扩容通过一个公开的方法 ensureCapacity(int minCapacity)来 实现。在实际添加大量元素前，我也可以使用 ensureCapacity 来手动增加 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);
    }
}


// 确保数组容量，容量不够进行扩容
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

// 计算最小容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

// 扩展数组容量
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

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

　　从上述代码中可以看出，数组进行扩容时，会将老数组中的元素重新拷贝一份到新的 数组中，

　　每次数组容量的增长大约是其原容量的 1.5 倍。

　　这种操作的代价是很高的，因此在 实际使用时，我们应该尽量避免数组容量的扩张。当我们可预知要保存的元素的多少时， 要在构造 ArrayList 实例时，就指定其容量，以避免数组扩容的发生。或者根据实际需求， 通过调用 ensureCapacity 方法来手动增加 ArrayList 实例的容量。

　　ArrayList 还给我们提供了将底层数组的容量调整为当前列表保存的实际元素的大小 的功能。它可以通过 trimToSize 方法来实现。代码如下:

public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}

4、读取方法

// 返回此列表中指定位置上的元素。
public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

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

5、删除方法

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



// 移除此列表中首次出现的指定元素(如果存在)。这是应为ArrayList中允许存放重复的元素。
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;
}

　　注意:从数组中移除元素的操作，也会导致被移除的元素以后的所有元素的向左移动一个 位置。

五、ArrayList源码分析 

　　

六、总结

　　1、ArrayList 创建时的大小为 0;当加入第一个元素时，进行第一次扩容时，默认容 量大小为 10。

　　2、ArrayList 每次扩容都以当前数组大小的 1.5 倍去扩容。

　　3、ArrayList 的 add、get、size 方法的复杂度都为 O(1)，remove 方法的复 杂度为 O(n)。

　　4、ArrayList 是非线程安全的（可以使用 Collections.synchronizedList(list) 方法解决List线程安全问题;）。