ArrayList——源码分析

ArrayList源码简单分析

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

ArrayList实现了RandomAccess，Cloneable，Serializable说明ArrayList是支持随机访问，可克隆，支持序列化的。其继承AbstractList，实现了List，说明其支持列表的相关操作，如添加、删除、判断是否为空、排序等等。

常用方法分析

构造方法

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

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

有参构造方法，根据传入的参数设置ArrayList底层数组的长度，如果传参为0的话数组为空数组。无参即默认使用空数组。

get()

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

    return elementData(index);
}

判断是否下标越界，没有的话就根据数组支持随机访问的特性获得该下标下的值。

set()

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

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

同上，检查下标，利用随机访问的特性去更新某一下标的值，将旧值返回。

add()

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

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

// 当数组为空数组时，返回默认数组长度为10，否则返回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);
}

grow()方法主要是对数组的扩容操作，扩容后的数组大小是原数组的1.5倍，同时将旧数组的内容拷贝到新数组上。

综上,每次添加会对size值加一，然后判断是否需要扩容，最后将数据添加到数组尾部。

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

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

根据add（E e） 分析可知，add(int index, E element)的逻辑为判断index的下标是否越界，然后判断是否需要进行扩容操作，接着根据数组的特性，将index + 1 ~ size的数组数据进行向后迁移。最后将数据插入到指定位置。

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 work

    return oldValue;
}

同add(int index, E element)类似，判断越界，迁移，最后将数组末尾的数据设为null，交由GC去执行回收。

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

遍历数组，进行相等判断，然后进行数据的迁移。

内部类Itr

ArrayList内嵌内部类Itr，支持迭代器。（这部分内容，读者自行了解，不加赘述）

private class Itr implements Iterator<E>

内部类SubList

private class SubList extends AbstractList<E> implements RandomAccess

SubList是List某一下标范围的视图。 具体了解可看博客：为什么阿里巴巴要求谨慎使用ArrayList中的subList方法 - 掘金 (juejin.cn)

内部类 ArrayListSpliterator

简单概括，就是支持多线程并发访问list。 详情看博客：ArrayListSpliterator内部类总结 | Husky (gddxh.github.io)