深入学习Java集合之ArrayList的实现原理

ArrayList 是List 接口的可变数组的实现,底层就是一个数组, 因此按序查找快, 乱序插入、删除因为涉及到后面元素移位所以性能慢。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

每个ArrayList 实例都有一个容量，该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList 中不断添加元素，其容量也自动增长。自动增长会带来数据向新数组的重新拷贝，因此，如果可预知数据量的多少，可在构造ArrayList 时指定其容量。在添加大量元素前，应用程序也可以使用ensureCapacity 操作来增加ArrayList实例的容量，这可以减少递增式再分配的数量。

注意，此实现不是同步的。如果多个线程同时访问一个ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。

【1】ArrayList 的实现

对于ArrayList 而言，它实现List 接口、底层使用数组保存所有元素。其操作基本上是对数组的操作，下面我们来分析ArrayList 的源代码。

其实现了RandomAccess 标明其是支持快速随机访问的。

public interface RandomAccess {
}

RandomAccess 内部是空的，标记“实现了这个接口的类支持快速（通常是固定时间）随机访问”。快速随机访问是什么意思呢？就是说不需要遍历，就可以通过下标（索引）直接访问到内存地址。

① 底层使用数组实现

//默认初始化容量，每次扩容1.5倍--new=1.5*old
private static final int DEFAULT_CAPACITY = 10;

//用于空实例的共享空数组实例
private static final Object[] EMPTY_ELEMENTDATA = {};

//共享空数组实例，用于默认大小的空实例。
//与EMPTY_ELEMENTDATA 区分开，以便了解添加第一个元素时需要扩容多少
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

//存储ArrayList的elements
transient Object[] elementData;

//ArrayList的size--包含的元素个数
private int size;

//数组分配最大值
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

② 构造方法

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

//构造一个默认初始容量10的空列表
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 的元素的列表，这些元素按照该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;
    }
}

---

③ 存储

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)这些添加元素的方法。

3.1 set(int index, E element)

用指定的元素替代此列表中指定位置上的元素，并返回以前位于该位置上的元素。

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

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

rangeCheck(index)用来检查index是否合法

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

检查给定索引是否在范围内。如果不是，则抛出适当的运行时异常。此方法不检查索引是否为负：它总是在数组访问之前立即使用，如果索引为负，则会抛出ArrayIndexOutOfBoundsException。

---

3.2 add(E e)

将指定的元素添加到此列表的尾部，其中add方法内部的ensureCapacityInternal(size + 1)方法会使modCount++，这与failFast机制有关。

代码如下所示，size表示实际元素的个数elementData[size++] = e表示先往elementData[size]位置放上e元素，然后size+=1

public boolean add(E e) {
	 // Increments modCount!!
    ensureCapacityInternal(size + 1); 
	//这里的size指的是列表中包含的元素个数
     elementData[size++] = e;
     return true;
 }

ensureCapacityInternal用来确保数组的大小，必要时会引起数组扩容。

private void ensureCapacityInternal(int minCapacity) {
	//如果底层数据为DEFAULTCAPACITY_EMPTY_ELEMENTDATA
  if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
  //将minCapacity 赋值为DEFAULT_CAPACITY和minCapacity中的大数
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

ensureExplicitCapacity确保明确的容量，也就是判断minCapacity是否会导致扩容。如果会则触发grow引起扩容。

private void ensureExplicitCapacity(int minCapacity) {
	// modCount用来记录结构的改变，在fail-fast机制会用到
    modCount++;

    // overflow-conscious code
    //如果溢出了，则扩容数组
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

将modCount++，并判断底层数据的length与minCapacity大小，若elementData.length<minCapacity ,需要扩容。

grow(int minCapacity)：

private void grow(int minCapacity) {
   // overflow-conscious code
   int oldCapacity = elementData.length;

//newCapacity =1.5*oldCapacity 
   int newCapacity = oldCapacity + (oldCapacity >> 1);
   
   //newCapacity 与minCapacity 比较
   if (newCapacity - minCapacity < 0)
       newCapacity = minCapacity;
       //newCapacity 与MAX_ARRAY_SIZE 比较
   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);
   //Arrays.copyOf(elementData, newCapacity);将会使用newCapacity作为length创建一个
   //新数组，将elementData中元素拷贝过去，并将新数组赋值给elementData 
}

hugeCapacity是用来确定最大值的。如果容量大于MAX_ARRAY_SIZE那么就返回 Integer.MAX_VALUE，否则就采用MAX_ARRAY_SIZE。

private static int hugeCapacity(int minCapacity) {
   if (minCapacity < 0) // overflow
         throw new OutOfMemoryError();
         //如果minCapacity大于MAX_ARRAY_SIZE，则取  Integer.MAX_VALUE；
         //否则取MAX_ARRAY_SIZE
     return (minCapacity > MAX_ARRAY_SIZE) ?
         Integer.MAX_VALUE :MAX_ARRAY_SIZE;
}
            

---

3.3 add(int index, E element)

将指定的元素插入此列表中的指定位置。 如果当前位置有元素，则向右移动当前位于该位置的元素以及所有后续元素（将其索引加1）

public void add(int index, E element) {
    rangeCheckForAdd(index);

// Increments modCount!! 这个与上面一致
    ensureCapacityInternal(size + 1);  
    //数组拷贝，移动index及后续索引位置--index都+1
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
      //在原index位置处放上将要添加的元素
    elementData[index] = element;
    //将元素个数+1
    size++;
}

rangeCheckForAdd(int index)-检查索引：

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

---

3.4 addAll(Collection<? extends E> c)

按照指定collection 的迭代器所返回的元素顺序，将该collection 中的所有元素添加到此列表的尾部。

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    //如果数组length不够，则将会扩容
    ensureCapacityInternal(size + numNew);  // Increments modCount
    //数组拷贝
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

3.5 addAll(int index, Collection<? extends E> c)

从指定的位置开始，将指定collection 中的所有元素插入到此列表中。

public boolean addAll(int index, Collection<? extends E> c) {
//索引检查
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
 
    //需要拷贝元素的个数
    int numNew = a.length;

    //数组容量检查，如果数组length不够，则扩容
    ensureCapacityInternal(size + numNew);  // Increments modCount

    int numMoved = size - index;

    //判断是否插入中间，如果是则“先腾空间--将元素往后移动numNew个单位”
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);

//将a中的元素从index=0开始拷贝到elementData中 index开始的位置
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

---

④ 读取

返回此列表中指定位置上的元素

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

    return elementData(index);
}

---

⑤ 删除

ArrayList 提供了根据下标或者指定对象等几种方式的删除功能。

5.1 remove(int index)

移除此列表中指定位置上的元素

public E remove(int index) {
//检查索引
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
//判断是移除中间还是末尾及以外的元素，如果是中间则进行数组拷贝--往前移动一个index单位
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
      //将原先列表末尾处元素赋值为null
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

5.2 remove(Object o)

移除此列表中首次出现的指定元素（如果存在）。这是因为ArrayList 中允许存放重复的元素。remove(Object o)是基于 fastRemove(index)进行元素移除的。

public boolean remove(Object o) {
//首先判断是否为null
    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;
}

fastRemove(index)：私有移除方法，与remove(int index)方法的区别是fastRemove(index)跳过边界检查且不返回 移除的值。

private void fastRemove(int index) {
//修改 modCount
    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
}

---

5.3 removeAll(Collection<?> c)

从列表中移除指定集合里面的元素，基于batchRemove(c, false)方法实现。

public boolean removeAll(Collection<?> c) {
     Objects.requireNonNull(c);
     return batchRemove(c, false);
 }

batchRemove(Collection<?> c, boolean complement)

private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
            //判断Collection是否包含elementData[r]，如果包含则进行下一轮判断；
            //否则将 r 位置元素 赋值给 w ，并将w+1;这个过程中w <= r。
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                //将w及以后的位置赋值为null
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

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

---

⑥ trimToSize

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

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

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

---

【2】Fail-Fast 机制

ArrayList 也采用了快速失败的机制，通过记录modCount 参数来实现。在面对并发的修改时，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

通过上面源码分析可知，在添加、移除或者手动扩容时，都会导致modCount++。

关于快速失败机制参考博文：浅谈从fail-fast机制到CopyOnWriteArrayList使用