ArrayList源码分析

前言：作为一个常用的List接口实现类，日常开发过程中使用率非常高，因此有必要对其原理进行分析。

注：本文jdk源码版本为jdk1.8.0_172

---

1.ArrayList介绍

ArrayList底层数据结构是数组（数组是一组连续的内存空间），默认容量为10，它具有动态扩容的能力，线程不安全，元素可以为null。

笔者在一次使用ArrayList的时候引起了一次线上OOM，分析传送门：记一次ArrayList产生的线上OOM问题

java.lang.Object
   ↳     java.util.AbstractCollection<E>
         ↳     java.util.AbstractList<E>
               ↳     java.util.ArrayList<E>

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}

2.主要源码分析

add(e)：

 public boolean add(E e) {
        // 确认容量
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 直接将元素添加在数组中
        elementData[size++] = e;
        return true;
}
    
 private void ensureCapacityInternal(int minCapacity) {
    // 进一步确认ArrayList的容量，看是否需要进行扩容
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
   // 如果elementData为空，则返回默认容量和minCapacity中的最大值
   if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 否则直接返回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;
    // 扩容，相当于扩大为原来的1.5倍
    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);
}

    

分析：

其实add方法整体逻辑还是比较简单。主要注意扩容条件：只要插入数据size比原来大就会进行扩容。因此如果在循环中使用ArrayList时需要特别小心，避免频繁扩容造成OOM异常。

add(int index, E element)：

public void add(int index, E element) {
        // 越界检查
        rangeCheckForAdd(index);
        
        // 确认容量
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 将index及其之后的元素往后移动一位，将index位置空出来
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 在index插入元素
        elementData[index] = element;
        // 元素个数自增
        size++;
    }

分析：

整体逻辑简单：越界检查->确认容量->元素后移->插入元素。

get函数：

public E get(int index) {
    // 越界检查
    rangeCheck(index);
    // 获取对应位置上的数据 
    return elementData(index);
}

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

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

分析：

get操作简单，理解容易。

remove(index):

public E remove(int index) {
    // 越界检查
    rangeCheck(index);
    
    // 修改次数自增
    modCount++;
    // 获取对应index上的元素
    E oldValue = elementData(index);
    
    // 判断index是否在最后一个位置
    int numMoved = size - index - 1;
    // 如果不是，则需要将index之后的元素往前移动一位
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 将最后一个元素删除，帮助GC
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

分析：

remove逻辑还是比较简单，但是这里需要注意一点是ArrayList在remove的时候，并没有进行缩容。

remove(o):

public boolean remove(Object o) {
    // 如果被移除元素为null
    if (o == null) {
        // 循环遍历
        for (int index = 0; index < size; index++)
            // 注意这里判断null是用的“==”
            if (elementData[index] == null) {
                // 快速remove元素
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            // 这里判断相等是用的equals方法，注意和上面对比
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

private void fastRemove(int index) {
    // 注意这里并未做越界检查，毕竟叫fastRemove
    // 修改次数自增
    modCount++;
    // 判断是否是最后一个元素，这里的操作和remove(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
}

分析：

remove元素的时候分为null和非null，并且是快速remove，并未做越界检查。

retainAll：求交集

public boolean retainAll(Collection<?> c) {
    // 判空
    Objects.requireNonNull(c);
    // 批量remove complement为true表示保存包含在c集合的元素，这样就求出交集了
    return batchRemove(c, true);
}

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++)
                // 如果c集合中包含遍历元素，则把元素放入写指针位置(以complement为准)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            // 正常情况下，r与size是相等的，这里是对异常的判断
            if (r != size) {
                // 将未读的元素拷贝到写指针后面
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            // 将写指针后的元素全部置空
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

分析：

将集合与另一个集合求交集，整体逻辑比较简单的。通过读写指针进行操作，不用额外空间。注意complement为true，则将包含在c中的元素写入相应位置。这样就求出了交集，这里还要注意finally中的操作，异常与置空操作。

removeAll：求差集，但是这里只保留当前集合不在C中的元素，不保留C中不在当前集合中的元素。

  public boolean removeAll(Collection<?> c) {
        // 判空
        Objects.requireNonNull(c);
        // 批量remove，注意这里complement为false，表示保存不在c中的元素，这样就求出差集了
        return batchRemove(c, false);
    }

分析：

逻辑和retainAll刚好相反，complement为false，保存不包含在C中的元素，这样就求出差集了，注意这里是单向差集。

3.总结

以上分析了ArrayList的主要源码，下面对其进行总结：

#1.ArrayList的底层数据结构为数组（数组是一组连续的内存空间），默认容量为10，线程不安全，可以存储null值。

#2.ArrayList扩容条件，只要增加容量大于现有容量就会进行扩容，扩容量为原来的1.5倍，但是ArrayList不会进行缩容。

#3.ArrayList中有求交集（retainAll）和求差集（removeAll），注意这里的差集是单向交集。

---

by Shawn Chen，2019.09.14日，下午。