ArrayList 一篇就够

平常开发中以下语句可能是最经常写的语句之一

List<Integer> list = new ArrayList<>();

结构 数组

继承关系

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

ArrayList实现的接口有Collection，List，RandomAccess，Serializable等接口。一个个看

1. RandomAccess
   接口中内容是空的，通过官网的API，这是一个标志接口，下面引入一段官网的原文：

public interface RandomAccess
Marker interface used by List implementations to indicate that they support fast (generally constant time) random access.
公共接口RandomAccess，List实现使用的标记接口，指示它们支持快速（通常为恒定时间）随机访问。
官网还特意说明了，如果是实现了这个接口的 List，那么使用for循环的方式获取数据会优于用迭代器获取数据。

2. Serializable
   接口中内容是空的，是一个标志接口
   一个类只有实现了Serializable接口，它的对象才能被序列化，将对象状态转换为可保持或传输的格式的过程。标识给jvm帮忙序列化。
3. Collection，List
   集合的统一接口。统一定义了一套单列集合的接口

核心属性

• DEFAULT_CAPACITY = 10; 默认初始容量。
• Object[] elementData; 数据区 数据存放的位置
• int size;当前List中的个数

构造方法

无参数构造方法，赋值个默认的空数组给数据区

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

指定容量构造方法，创建一个指定大小的Object数组赋值给数据区

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

指定数据构造方法，创建一个List并且放入参数集合中的元素

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

核心方法 public boolean add(E e)

modCount，这个成员变量记录着集合的修改次数，也就每次add或者remove它的值都会加1，因为ArrayList不是线程安全的，如果一个在线程在修改，一个线程在读，那么modCount不相等用来做快速失败的。
接着检查是否需要扩容，size+1如果大于数组可存放的长度就进行grow扩容，反之存放进数组中下一个位置，增加size。

public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}
 
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

核心方法 private void grow(int minCapacity)

扩容以确保它至少可以容纳当前所有元素。
oldCapacity >> 1 将二进制整体右移指定位数，类似除以2向下取整。新的容量是旧的容量的1.5倍
最后使用Arrays.copyOf()创建一个新的数组并且将元素拷贝到新的数组返回。
数组 Arrays.copyOf(源,需要拷贝的长度)

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //在第一次add时oldCapacity=0，newCapacity=0,做的处理
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    //检查是否超过最大可存放数
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

核心方法 public E get(int index)

返回此列表中指定位置的元素，没啥好说的用下标访问数组

public E get(int index) {
    //做一个index范围检查，大于等于size则越界抛错
    rangeCheck(index);
    return (E) elementData[index];
}

System.arraycopy

System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
Object src : 原数组
int srcPos : 从元数据的起始位置开始
Object dest : 目标数组
int destPos : 目标数组的开始起始位置
int length : 要copy的数组的长度

核心方法 public E remove(int index) 根据下标移除元素

移除指定下标位置的元素。
将下标的后面的所有元素向前移动一格。如果下标在末尾则不需移动。

public E remove(int index) {
    //下标是否越界检查
    rangeCheck(index);
    modCount++;
    //先获取需要移除的元素
    E oldValue = (E) elementData[index];
    //确定要移动的元素个数
    int numMoved = size - index - 1;
    //如果去除的是最后一个元素，则元素不必移动
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,numMoved);
    //清楚引用，help gc
    elementData[--size] = null; 
    return oldValue;
}

核心方法 public boolean remove(Object o) 移除相等元素

没啥好说的，遍历数组然后比较，相同就调用fastRemove移除，代码和上文中的移除元素一致。
比较调用的是equals方法，所以要求你存放的对象重写equals方法，不然比较的是地址，具体看业务需求。

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

与上文移除元素一样的代码

private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,numMoved);
    elementData[--size] = null; 
}