Java集合源码解析 - ArrayList

概述

ArrayList是一个以动态数组(支持扩展)实现的List(非线程安全)

UML类图

ArrayList实现了List接口，提供了增删改查的基础操作；

ArrayList实现了Serializable接口，可以被序列化；

ArrayList实现了Cloneable接口，可以被克隆；

ArrayList实现了RandomAccess接口，支持随机访问；

源码解析

属性

/**
 * 默认容量为10
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 空数组，如果传入的容量为0时使用
 * new ArrayList(0)
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 默认空数组，无参构造时赋值给elementData，添加第一个元素的时候会重新初始为默认容量大小
 * new ArrayList()
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 存储元素的数组
 * 设置为transient,该对象不可被序列化
 * 但是ArrayList重写了WriteObject()与readObject()，实际上数组里的元素会被实例化
 */
transient Object[] elementData;

/**
 * 集合中元素的个数(默认0)
 */
private int size;

构造器

/**
 * 无参构造器，则使用默认空数组
 * 添加第一个元素是扩容到默认大小10
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * 传入初始容量>=0
*/
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        //初始容量大于0，新建数组存储元素
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        //初始容量等于0，使用空数组
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
    }
}

/**
 * 传入集合
 */
public ArrayList(Collection<? extends E> c) {
    //集合转数组，并赋值
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // 由于子类可以重写Collection的toArray接口，所以返回类型不一定是Object[]类型，需要加判断
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 如果长度为0，赋值空数组
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

方法

add(E e)

功能

添加元素到数组末尾，平均时间复杂度O(1);

流程

1. 检查是否需要扩容；
2. 判断本次的最小容量与数组容量大小，大于转步骤3，小于转步骤5；
3. 新容量默认扩大为旧容量的1.5倍，如果还小于本次的最小容量，则新容量=本次的最小容量；如果新容量大于最大数组容量，调用hugeCapacity(int minCapacity)赋值最大容量；
4. 复制旧数据到新数组；
5. 将元素添加至数组末尾；

源码

public boolean add(E e) {
    //检查是否需要扩容
    ensureCapacityInternal(size + 1); 
    //元素插入到最后一位
    elementData[size++] = e;
    return true;
}

/**
 * minCapacity 数组需要的最小容量
 */
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //如果数组是默认空数组，返回默认容量10
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    //fail-fast机制
    modCount++;
    // 如果需要的数组长度>已有的数组长度，扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // 旧数组容量
    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);
    // 拷贝旧数组数据
    elementData = Arrays.copyOf(elementData, newCapacity);
}

add(int index, E e)

功能

添加元素到数组指定位置，平均时间复杂度O(n);

流程

1. 检查数组是否越界
2. 检查数组是否扩容
3. 将index及之后元素往后移动一位，空出index位，指定index位赋值

源码

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;
    //数组元素+1
    size++;
}

/**
 * 检查数组是否越界
 */
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

get(int index)

功能

根据指定下标返回数据，平均时间复杂度O(1);

流程

1. 检查数组是否越界

2. 返回指定下标的数据

源码

public E get(int index) {
    //检查数组是否越界
    rangeCheck(index);
    //返回指定下标的数据
    return elementData(index);
}

remove(int index)

功能

功能：删除并返回指定下标的数据，平均时间复杂度为O(n)

流程

1. 检查数组越界
2. 获取指定下标元素
3. 将index+1处开始的numMoved个元素，移动到index处
4. 清除最后一位元素
5. 返回值

源码

public E remove(int index) {
    //检查数组越界
    rangeCheck(index);
    //修改次数+1
    modCount++;
    //获取指定下标的数据
    E oldValue = elementData(index);
    //移动的元素个数
    int numMoved = size - index - 1;
    //需要移动，从index+1处开始的numMoved个元素，移动到index处
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //清除最后一位
    elementData[--size] = null; // clear to let GC do its work
    //返回值
    return oldValue;
}

总结

ArrayList使用数组存储元素，当数组长度不够时扩容，默认为原来的1.5倍(若小于本次新增最小容量，默认使用本次新增最小容量)，扩容后不可压缩
ArrayList支持随机访问，通过下标访问速度极快，平均时间复杂度O(1)
ArrayList添加数据到尾部速度极快，平均时间复杂度O(1)
ArrayList添加数据到指定位置速度较慢，需要移动元素，平均时间复杂度O(n)
ArrayList删除尾部数据速度极快，平均时间复杂度O(1)
ArrayList删除指定位置数据速度较慢，需要移动元素，平均时间复杂度O(n)
线程安全可使用Collections.synchronizedList(List list)、Vector、CopyOnWriteArrayList

QA

Q：elementData为什么设置成了transient，怎么进行序列化？

A：序列化是以流的方式来进行处理，ArrayList重写了writeObject()与readObject()方法。如果将数组所有的数据(包括为null的)都序列化到磁盘，那么会浪费许多空间，重写的writeObject()只是将前size个数组数据序列化，有效的降低消耗。