Java集合类源码分析（二）：List接口之ArrayList实现类

系列文章目录

Java集合类源码分析（一）：Java集合类总览
Java集合类源码分析（二）：List接口之ArrayList实现类
Java集合类源码分析（三）：List接口之ArrayList实现类
Java集合类源码分析（四）：List接口之Vector实现类
Java集合类源码分析（五）：Map接口之HashMap实现类
Java集合类源码分析（六）：Map接口之HashTable实现类
Java集合类源码分析（七）：Map接口之LinkedHashMap实现类
Java集合类源码分析（八）：Map接口之TreeMap实现类

        集合类中第一大部分即是List集合，List是一种有序可重复，底层是一维数组的集合。

一、List特性

1. 可以存放同一种类型的元素。
2. 内部维护元素之间的顺序,是有序集合。
3. 元素是可以重复的。

        根据List集合框架图（如下），实现List接口的集合类主要有ArrayList、LinkedList、Vector类。其中ArrayList、LinkedList较为常用。今天我们就来聊聊ArrayList的实现原理。

二、ArrayList关注重点：

1.ArrayList基于数组实现，可以通过下标索引直接查找到指定位置的元素，因此查找效率高，但每次插入或删除元素，就要大量地移动元素，插入删除元素的效率低。

2.在查找给定元素索引值等的方法中，源码都将该元素的值分为null和不为null两种情况处理，ArrayList中允许元素为null。

3.ArrayList不是线程安全的，如果需要多线程并发操作应当使用CopyOnWriteArrayList，或者使用Collections工具类的synchronizedList方法将其包装。

4.ArrayList实现类RandomAccess接口（标记接口），说明它支持快速访问。
        RandomAccess接口主要用在Collections工具类上，Collections提供了大量静态方法操作集合，在需要遍历元素的时候，会根据一个集合是否实现了RandomAccess接口来采取用for循环遍历还是用迭代器遍历。对于ArrayList来说，采用for循环遍历更快，对于LinkedList来说，采用迭代器遍历更快。

5.System.arraycopy()方法。

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

参数：
src：源数组，
srcPos：源数组要复制的起始位置
dest：目的数组
destPos：目的数组放置的起始位置；
length：复制的长度
注意： src and dest都必须是同类型或者可以进行转换类型的数组。

        该方法被标记了native，调用了系统的C/C++代码，实现数组之间的复制。因此它可以保证同一个数组内元素的正确复制和移动，比一般的复制方法的实现效率要高很多，很适合用来批量处理数组。

三、ArrayList类继承结构图

首先看看ArrayList的继承关系：

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

        可以看到ArrayList类实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了RandomAccess接口，支持快速随机访问，实现了Cloneable接口，能被克隆。

四、关键源码分析

基本属性

    /**
     * Default initial capacity.
     * 默认容量为10
     */
    private static final int DEFAULT_CAPACITY = 10;
    
	/**
	 * 初始化一个空的数组，用于ArrayList无参构造函数创建时赋值
	 */
	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

	/**
	 *	ArrayList用该数组保存数据
	 */
	transient Object[] elementData;

构造函数

	/**
	 *	初始化容量的构造函数
	 */
	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);
        }
    }
    
    /**
     * 无参构造函数，则容量默认为10
     */ 
	public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

集合容量相关

	/**
	 * 将当前集合中的元素容量值赋值给实际容量size
	 */
	public void trimToSize() {
		// 对list有结构性修改的次数（AbstractList抽象类属性）
		// 若该值发生不可期望的修改，iterator会抛出ConcurrentModificationException异常
		// 此值提供了一个fast-fail机制
        modCount++; 
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

	/**
	 * 确定当前list容量
	 */
	public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    
	private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        // 新容量 = 原容量 + 原容量/2 = 原容量 * 1.5
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
        // 与MAX_ARRAY_SIZE比较得到最终容量大小
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
	
	/**
	 * 分配给array的最大容量，有一个VMs保留一部分头部信息在数组中
	 */
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
	public int size() { return size; }
	public boolean isEmpty() { return size == 0; }
	public boolean contains(Object o) { return indexOf(o) >= 0; }

查询元素在集合中的索引

 	/**
 	 * 返回所匹配的元素第一次出现的索引
 	 */
	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;
    }
	public Object[] toArray() { return Arrays.copyOf(elementData, size); }

集合操作相关（get、set、add、remove等）

	/**
	 * 获取index位置的元素值
	 */
	public E get(int index) {
		// 校验index是否是在范围内
        rangeCheck(index);
        return elementData(index);
    }

	/**
	 * 设置index位置的值位element
	 */
	public E set(int index, E element) {
        rangeCheck(index);
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

	/**
	 * 在list的末尾添加一个元素e
	 */
	public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
	
	/**
	 * 将元素element添加到index位置
	 */
	public void add(int index, E element) {
		// 校验index是否在范围内
        rangeCheckForAdd(index);
        // 确保添加后list容量满足
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 插入时移动index+1后面的size - index个元素
        // 所以ArrayList插入效率较低	
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

	/**
	 * 删除ArrayList指定位置的Element
	 */
	public E remove(int index) {
		// index 校验
        rangeCheck(index);
		// 对ArrayList结构性修改次数+1
        modCount++;
        E oldValue = elementData(index);
        int numMoved = size - index - 1;
        if (numMoved > 0)
            // 将index后的元素前移
            System.arraycopy(elementData, index+1, elementData, 
            				index, numMoved);
        // 将原elementData最后一个索引处元素置空
        elementData[--size] = null; // clear to let GC do its work
        // 返回删除的元素
        return oldValue;
    }

	/**
	 * 删除指定元素，且为在list中第一次出现的位置的元素，若有返回true，否则返回false
	 */
	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;
    }

	/**
	 * 快速移除list中指定位置元素，与remove(int index)类似，
	 */ 
	private void fastRemove(int index) {
		// 修改list结构次数+1
        modCount++;
        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
    }
	/**
	 * 将集合C追加至ArrayList集合中
	 */
	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;
    }

	/**
	 * 从ArrayList集合的index索引开始，将集合C插入至其中
	 */
    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;
    }

	/**
	 * 删除ArrayList中索引从fromIndex至toIndex之间的元素
	 */
	protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, 
        				fromIndex, numMoved);
        // clear to let GC do its work
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }

	/**
	 * 删除ArrayList中包含集合C中的元素
	 */
	public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }

ArrayList的序列化方法（writeObject用来写入信息，readObject用于读取信息）

	/**
	 * 将ArrayList的“容量，所有的元素值”都写入到输出流中
	 */
	private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();
        // Write out size as capacity for behavioural 
        // compatibility with clone()
        s.writeInt(size);
        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

	/**
	 * 先将ArrayList的“容量”读出，然后将“所有的元素值”读出 
	 */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;
        // Read in size, and any hidden stuff
        s.defaultReadObject();
        // Read in capacity
        s.readInt(); // ignored
        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            int capacity = calculateCapacity(elementData, size);
            SharedSecrets.getJavaOISAccess()
            .checkArray(s, Object[].class, capacity);
            ensureCapacityInternal(size);
            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

List转Iterator

	/**
	 * 将list转为迭代器
	 */
    public ListIterator<E> listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }

以上为个人学习的理解，如有错误，欢迎指正！