【java】ArrayList1.8源码详解

前言

ArrayList是java编程中最常用的工具类之一，它解决了普通数组无法自动扩容的问题，是一个非常简单而又强大的工具，本篇博文将带你揭开ArrayList1.8神秘的面纱。

概要

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

ArrayList继承了AbstractList抽象类，实现了List、RandomAccess、Cloneable、Serializable接口；List接口规定了ArrayList的操作规范，RandomAccess是一个标志接口，意味着ArrayList支持快速随机访问，Cloneable接口用于克隆，Serializable接口则用来支持对象的序列化与反序列化。

ArrayList的数据结构不像HashMap那么复杂，它的存储由数组提供支持。因为数组是可以为空的，所以ArrayList可以存储多个null对象。

属性

// 默认初始容量
private static final int DEFAULT_CAPACITY = 10;

// 当指定数组的容量为0的时候使用这个变量赋值，空对象数组 
private static final Object[] EMPTY_ELEMENTDATA = {};

// 默认实例化的时候使用此变量赋值，空对象数组
// 用来区别EMPTY_ELEMENTDATA，后面将会详细解释
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// 用来存储数据的数组，非私有以简化嵌套类的访问
// transient关键字表明此成员不参与对象序列化
transient Object[] elementData;

// 已存储元素的个数
private int size;

// 由于VM的限制，一般容量不要超过MAX_ARRAY_SIZE，但最大值可以是Integer.MAX_VALUE
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

构造方法

// 单参构造
public ArrayList(int initialCapacity) {
	// 未限制initialCapacity的大小，所以最大容量为Integer.MAX_VALUE
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
    	// 容量为0，将第一个空数组赋值给它
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

// 构造一个初始容量为10的空列表。
public ArrayList() {
	// 默认情况下，赋值第二个空数组，表示容量为默认初始容量
	// 这也就是为什么给了两个空数组对象，就为了将两种情况区别开
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// 用另一个集合来初始化本对象
public ArrayList(Collection<? extends E> c) {
	// 得到缓存数组，赋值给成员elementData
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray可能(不正确地)不返回Object[]
        // 当泛型是String时，返回的是String[]
        if (elementData.getClass() != Object[].class)
        	// 此方法将详细讲解
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 用空数组替换，容量为0
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

Arrays.copyOf()

// original: 原数组，newLength: 复制长度，newType: 返回数组的类型
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
 	// 如果是Object[].class，则new Object[newLength]
	// 如果不是，则Array.newInstance(newType.getComponentType(), newLength);
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        // newType.getComponentType()可以得到数组类型
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        
    // 复制的长度不能超过原数组的最大值，否则可能会出现下标越界的问题   
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

System.arraycopy() 是一个本地方法，这个方法将src作为原数组，从srcPos起开始复制，复制到目标数组dest中，dest数组从destPos开始复制，一共复制length个；而在方法的参数中，src和dest并不是数组类型，因此可以猜测，此方法应该是通过物理内存的起始地址和偏移量来完成复制的。

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

核心方法

此模块将列举一些常用的方法，也会对关联的方法进行讲解。

get(int index)

@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}

public E get(int index) {
	// 检查数组下标的范围，防止下标越界
    rangeCheck(index);

    return elementData(index);
}

rangeCheck(int index)

// 封装的下标越界检查，被get()、remove()等方法使用
private void rangeCheck(int index) {
	// 并没有检查下标是否小于0，因为在elementData[index]操作中，
	// jvm会帮我们检查越界问题
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

// 构造异常的具体信息
private String outOfBoundsMsg(int index) {
    return "Index: "+index+", Size: "+size;
}

set(int index, E element)

public E set(int index, E element) {
	// 检查下标
    rangeCheck(index);

	// 替换旧值
    E oldValue = elementData(index);
    elementData[index] = element;
    
	// oldValue 可能为 null  
    return oldValue;
}

add(E e)

// 在数组有效元素末尾插入
public boolean add(E e) {
	// 添加前判断容量够不够，不够扩容；最重要的是增量modCount
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}
// 指定下标插入元素
public void add(int index, E element) {
	// 检查下标的合法性
    rangeCheckForAdd(index);

	// 添加前判断容量够不够，不够扩容；最重要的是增量modCount
    ensureCapacityInternal(size + 1);
    // 数组元素后移，留下该下标元素的位置，为插入element做准备
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 插入元素
    elementData[index] = element;
    size++;
}

rangeCheckForAdd(int index)

// 由add()和addAll()使用的版本
// add()和addAll()中调用了native的System.copyOf()方法
// 所以需要判断 index < 0，与rangeCheck(int index)不同
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

ensureCapacityInternal(int 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) {
	// 修改数+1，调用此方法的方法不用再写这一步
    modCount++;

	// 如果需要的最小容量大于数组长度，则扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

grow(int minCapacity) - 扩容

//增加容量，以确保至少可以容纳由minCapacity指定的元素数量
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    
    // oldCapacity >> 1 = oldCapacity * 1/2
    // oldCapacity + oldCapacity / 2 = oldCapacity * 3/2
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    
    // 计算的新容量小于要求的最小容量(minCapacity)，则选择最小容量
    // 如果大于，使用计算的容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
        
    // 如果newCapacity大于MAX_ARRAY_SIZE，就尝试用最小容量
   	// 若minCapacity也超过了MAX_ARRAY_SIZE，则用Integer.MAX_VALUE
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
        
    // minCapacity通常接近于size，所以复制效率较高
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // 溢出
        throw new OutOfMemoryError();
    // 最大值可以是 Integer.MAX_VALUE
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

addAll(Collection<? extends E> c)

// 所以元素尾加到elementData中
public boolean addAll(Collection<? extends E> c) {
	//  将List变为Object数组
    Object[] a = c.toArray();
    int numNew = a.length;
    // 确保容量足够
    ensureCapacityInternal(size + numNew);  // 增量modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

// 所以元素插入到elementData数组的指定index中
public boolean addAll(int index, Collection<? extends E> c) {
	// 检查下标合法性
    rangeCheckForAdd(index);

	// 将List变为Object数组
    Object[] a = c.toArray();
    int numNew = a.length;
    // 确保容量足够
    ensureCapacityInternal(size + numNew);  // 增量modCount

    int numMoved = size - index;
    if (numMoved > 0)
    	// 先将位置空出来，为插入作准备
	    System.arraycopy(elementData, index, elementData, index + numNew,
	                         numMoved);
	// 这里省去了for循环的赋值
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

toArray()

// elementData的浅克隆（测试得出）
public Object[] toArray() {    	
    return Arrays.copyOf(elementData, size);
}
//public static <T> T[] copyOf(T[] original, int newLength) {
//    return (T[]) copyOf(original, newLength, original.getClass());
//}

@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
	// 数据可能会丢失，根据用户给的数组确定，a.length
    if (a.length < size)
		// 返回的数组的长度为size，但a的长度不够保存
		// 所以会有部分数据丢失，且a数组被填满
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    
    // 返回的数组的长度为a.length
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
   		// 若a.length = size，不会执行这一步
   		// 数组下标从 0 到 size - 1，共size个
        a[size] = null;
    return a;
}

remove(Object o)

// 删除指定下标元素
public E remove(int index) {
    rangeCheck(index);

	// 修改数+1
    modCount++;
    // 取得要删除的数据
    E oldValue = elementData(index);

	// 需要移动的个数
    int numMoved = size - index - 1;
    if (numMoved > 0)
		// 这里直接就覆盖了该元素，不用再进行删除的那一步
	    System.arraycopy(elementData, index+1, elementData, index,
	                     numMoved);
   	// 清除，让GC做它的工作
    elementData[--size] = null;

    return oldValue;
}

// 删除第一个匹配的元素（从头遍历），没有则返回false
public boolean remove(Object o) {
    if (o == null) {
   		// 从头开始遍历，找到第一个匹配的元素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;
}

// 工具内部的删除，一定是对象匹配才能删，所以不用rangeCheck(index)
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;
}

// 暴力删除，让gc回收
public void clear() {
    modCount++;

    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

iterator()

// 按适当的顺序对列表中的元素返回一个迭代器。
public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
	 // 下一个要返回的元素的索引
    int cursor;      
    // 最后一个返回元素的索引(上一个返回的元素);如没有返回-1
    int lastRet = -1; 
    // 确定修改数，保证线程安全
    int expectedModCount = modCount;  

    Itr() {}

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
   		// 检查修改数是否相同，判断线程的安全性
        checkForComodification();
        // 第一次为0，因为int成员初始值为0
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
            
        Object[] elementData = ArrayList.this.elementData;
        // 上面已经判断i < size成立，而size <= elementData.length
        // 所以下面条件成立则说明进行了容量收缩，线程不安全
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            // 保证修改数同步，不会造成线程不安全
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
    		// 如果下标越界了，那么肯定是对elementData进行了删除等操作
            throw new ConcurrentModificationException();
        }
    }

	// 显式的forEach调用，遍历剩下的所有元素
    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
   		// 判断consumer 是否为 null
        Objects.requireNonNull(consumer);
        // final关键字修饰，不可更改
        final int size = ArrayList.this.size;
        // 接着之前的继续遍历
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        // 遍历后面的元素，并判断修改数是否相同，如果不同立即停止循环
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // 确定下一个返回值的下标和上一个返回值的下标
        cursor = i;
        lastRet = i - 1;
        // 检查线程同步
        checkForComodification();
    }

	// 通过修改数的对比，判断是否对原数组进行了修改
    // 在产生Itr对象时，就确定了expectedModCount的大小
    // 如果在外部类进行了修改操作，就会被认为是线程不安全的行为
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

总结

到此，ArrayList1.8的基本属性、构造方法和它的核心方法已经基本讲解完毕了，希望读者能从中有所收获。