ArrayList源码解析

ArrayList：

底层是数组：查询快、增删慢、线程不安全。我们正常使用的场景中，都是用来查询，不会涉及太频繁的增删，List的实现类中使用最频繁。线程安全版有juc包下的CopyOnWriteArrayList。

方法详解

三种构造方法

ArrayList可以通过构造方法（有参）在初始化的时候指定底层数组的大小。

无参构造器则默认初始容量大小为 10;

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

/**
 * Constructs an empty list with an initial capacity of ten.
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//注意：注释是说构造一个容量大小为 10 的空的 list 集合，但构造函数了只是给 elementData 赋值了一个空的数组，其实是在第一次添加元素时容量扩大至 10 的。	CAPACITY是容量的意思


//使用指定 Collection 来构造 ArrayList 的构造函数
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();//将 Collection 转化为数组并赋值给 elementData
    if ((size = elementData.length) != 0) {
        // 如果 size 不为零，则判断 elementData 的 class 类型是否为 Object[]，不是的话则做一次转换。
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 如果为0 则将EMPTY_ELEMENTDATA 赋值给 elementData，相当于new ArrayList(0)
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

两个空数组

/**
 * Shared empty array instance used for empty instances.
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * Shared empty array instance used for default sized empty instances. We
 * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
 * first element is added.
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//区别出elementData 在首次添加元素时根据初始化的方式确定如何如何扩容（默认则是10）

以下是主要操作方法解析

两个重要成员变量

transient Object[] elementData; // non-private to simplify nested class access

private int size;
//上面的 size 是指 elementData 中实际有多少个元素，而 elementData.length 为集合容量，表示最多可以容纳多少个元素。

四个add方法

1.boolean add(E e)

public boolean add(E e) {
    //确认内部容量是否够用（不够就扩容），没有扩容因子
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //在数据中正确的位置上放上元素e，并且size++
    elementData[size++] = e;
    return true;
}

//确定内部容量的方法
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //选大的，至少也是10（初始化时或者没到第一次扩容时，都是10）
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //如果是空数组，或者当前所需容量小于10则返回10
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // 判断是否扩容
    if (minCapacity - elementData.length > 0)
        //arrayList核心的方法，能扩展数组大小的真正秘密。
        grow(minCapacity);
}

//核心：扩容方法（包括初始化时扩容到10）
//核心还是Arrays.copyOf，这个方法主要是确认心容量的大小
private void grow(int minCapacity) {
    //旧 新 所需要的
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //newCapacity就是1.5倍的oldCapacity
    int newCapacity = oldCapacity + (oldCapacity >> 1);//右移一位，除2
    
    //新是0，所需要就是10
    if (newCapacity - minCapacity < 0)//此时newCapacity是0的，就是没有初始化的大小
        newCapacity = minCapacity;//扩容到10
    
    //如果newCapacity超过了最大的容量限制，就调用hugeCapacity，也就是将能给的最大值给newCapacity
    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);
}

private static int hugeCapacity(int minCapacity) {//用来赋最大值
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}


private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//最大容量限制

2.void add(int index, E element)

public void add(int index, E element) {
    //检查位置是否在数组范围内
    rangeCheckForAdd(index);
	//确认内部容量是否够用（不够就扩容）
    ensureCapacityInternal(size + 1);  
    //这个方法就是用来在插入元素之后，要将index之后的元素都往后移一位，
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

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

添加元素本质就是在数组上插入元素，默认添加是添加到元素末尾的，也可以指定位置添加。

添加之前都会检查数组容量是否够用，决定是否扩容，扩容后为原数组容量的1.5倍。

还有两种不常用的添加方法，直接将一个集合添加进去。

//本质是arraycopy
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;
}

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

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;//返回旧对象
}

remove方法

由此可以看出arrayList可以存储null值

//根据下标删除
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;
}
//根据对象删除
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;
}
//清空
public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}
//删除和插入都是System.arraycopy实现的

//批量删除指定元素
public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);//判空
    return batchRemove(c, false);
}
//batchRemove(xx,xx)：用于两个方法，一个removeAll()：它只清楚指定集合中的元素，retainAll()用来测试两个集合是否有交集。

indexOf()方法

//返回指定元素的第一个索引
public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}
//返回指定元素的最后一个索引
public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

arrayList实现了RandomAccess，所以在遍历它的时候推荐使用for循环。