ArrayList源码解析

1.特点

• 底层: ArrayList是List接口的大小可变数组的实现
• 是否允许null: ArrayList允许null元素
• 时间复杂度: size、isEmpty、get、set、iterator和listIterator方法都以固定时间运行，时间复杂度为O(1)。add和remove方法需要O(n)时间
• 容量: ArrayList的容量可以自动增长(扩容)
• 是否同步: ArrayList不是同步的,也就是非线程安全的
• 迭代器: ArrayList的Iterator和ListIterator方法返回的迭代器都是fail-fast(快速 失败)的

2.定义

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

3.域

/**
 * 数组默认初始化容量
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 指定ArrayList容量为 0 时,返回该空数组
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 当调用无参构造方法时,返回的是该数组.刚创建一个ArrayList时,其内数据量为0.
 * 它与 EMPTY_ELEMENTDATA的区别在于: 该数组是默认返回的,而后者是指定容量为 0时返回的
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 保存添加到ArrayList中的元素.
 * ArrayList的容量就是该数组的长度.
 * 该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入ArrayList中时，数组将扩容值DEFAULT_CAPACITY.
 * 被标记为transient，在对象被序列化的时候不会被序列化.
 */
transient Object[] elementData;

/**
 * ArrayList的实际大小(数组包含的元素个数)
 */
private int size;

==注意==: elementData被transiet修饰,那么在对象被序列化的时候,它不会被序列化.而ArrayList自定义了序列化和反序列化.详情请查看writeObject(java.io.ObjectOutputStream s)和readObject(java.io.ObjectOutputStream s)方法

4.构造方法

ArrayList提供了三种构造方法

• ArrayList(int initialCapacity): 构造一个指定容量为initialCapacity的空ArrayList
• ArrayList(): 构造一个初始容量为10的空ArrayList
• ArrayList(Collection

 /**
 * 构造一个指定初始化容量为capacity的空ArrayList。
 *
 * @param  initialCapacity  ArrayList的指定初始化容量
 * @throws IllegalArgumentException  如果ArrayList的指定初始化容量为负。
 */
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);
    }
}

ArrayList()

/**
 * 构造一个初始容量为10的空 ArrayList
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

ArrayList(Collection

/**
 * 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
 *
 * @param c 其元素将放置在此列表中的 collection
 * @throws NullPointerException 如果指定的 collection 为 null
 */
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

5.核心方法

方法名	时间复杂度
get(int index)	O(1)
add(E e)	O(n)
add(int index, E e)	O(n)
remove(E e)	O(n)
set(E e)	O(1)

get(int index)

/**
 * 返回list中索引为index的元素
 *
 * @param  索引
 * @return 返回元素
 * @throws IndexOutOfBoundsException 数组下标越界异常
 */
public E get(int index) {
    //越界检查
    rangeCheck(index);
    //返回元素
    return elementData(index);
}
/**
 * 越界检查。
 * 检查给出的索引index是否越界。
 * 如果越界，抛出运行时异常。
 * 这个方法并不检查index是否合法。比如是否为负数。
 * 如果给出的索引index>=size，抛出一个越界异常
 */
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

add(E e)

/**
 * 添加元素到list末尾
 *
 * @param 被添加的元素
 * @return 
 */
public boolean add(E e) {
    //第一次添加元素时,给ArrayList赋长度,检测容量是否足够,不足就将扩容
    ensureCapacityInternal(size + 1); 
    //将元素添加到数组最末
    elementData[size++] = e;
    return true;
}

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

/**
 * 获取容量值
 */
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //如果数组为DEFAULTCAPACITY_EMPTY_ELEMENTDATA,则minCapacity取10和minCapacity中大的那个
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

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

    // 如果容量不足则进行扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

/**
 * 分派给arrays的最大容量
 * 为什么要减去8呢？
 * 因为某些VM会在数组中保留一些头字，尝试分配这个最大存储容量，可能会导致array容量大于VM的limit，最终导致OutOfMemoryError。
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private void grow(int minCapacity) {
    //获取当前数组的容量
    int oldCapacity = elementData.length;
    //扩容.增加当前容量的一半
    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);
}

private static int hugeCapacity(int minCapacity) {
    //小于 0 抛出异常
    if (minCapacity < 0) 
        throw new OutOfMemoryError();
    //如果想要的容量大于MAX_ARRAY_SIZE,则分配Integer.MAX_VALUE;否则分配MAX_ARRAY_SIZE
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

扩容方法总结:

①进行空间检查,决定是否进行扩容,以及决定最少需要的容量

②如果需要扩容,就执行grow(int minCapacity),minCapacity为最少需要的容量

③第一次扩容,在原有容量基础上增加一半

④第一次扩容后,如果容量还是小于minCapacity,那就再次扩容为minCapacity

⑤对扩容后的容量进行判断,如果大于允许的最大容量MAX_ARRAY_SIZE,则再次将容量扩展为Integer.MAX_VALUE

add(int index, E element)

/**
 * 在指定位置插入元素,当前位置的元素和index之后的元素向后移动一位
 */
public void add(int index, E element) {
    //越界检查
    rangeCheckForAdd(index);
    //确认list容量,如果容量不够,就进行扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //对数组进行复制处理,目的就是空出index的位置插入element,并将index后的元素向后移动一位
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    //将指定元素插入index的位置
    elementData[index] = element;
    //长度+1
    size++;
}

remove(int index)

/**
 * 删除list中指定索引index位置的元素
 */
public E remove(int index) {
    //检查索引是否越界
    rangeCheck(index);
    //结构性修改次数+1
    modCount++;
    //记录索引为index处的元素
    E oldValue = elementData(index);
    //删除指定元素后,需要左移的元素个数
    int numMoved = size - index - 1;
    //如果有需要左移的元素就移动(移动后,需要删除的元素就被覆盖了)
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //size-1,然后将size-1处的元素置为null.为了让GC起作用,必须显式的为最后一个元素赋值null
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

删除指定位置元素的步骤:

1.检查索引是否越界

2.将索引大于index的元素左移一位(左移后,index位置的元素就被覆盖了,也就相当于被删除了)

3.将索引位置为size-1处的元素置为null(为了让GC起作用)

https://blog.csdn.net/panweiwei1994/article/details/76760238