Java集合源码解析之ArrayList

uml类图：

基本简介：

1. ArrayList的底层数据结构是数组，所以内存需要为arrayList保证有足够的连续的内存空间。
2. 添加操作会导致数组扩容，数组扩容比较消耗性能。
3. 非尾部的添加和删除元素操作会涉及数组元素的移动，也比较消耗性能。
4. 由于是数组结构，所以可以通过下标进行随机访问，时间复杂度为O(1)，性能好。

这里只讲部分重要的方法：

modCount成员在AbstractList中定义，这个记录着集合对象的修改次数，是failfast机制的判断依据。

failfast机制请看：https://blog.csdn.net/qq_40837310/article/details/103993535

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

    //默认的数组大小
    private static final int DEFAULT_CAPACITY = 10;

   //一个类共享的空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

//ArrayList的容量阈值，但不是最大容量
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
	

	//一个类共享的默认数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    //真正装载元素的数组，ArrayList的底层结构就是它
    transient Object[] elementData; // non-private to simplify nested class access

    //记录着元素的个数
    private int size;

/**
* 构造器，传入指定的初始化时的数组长度大小，如果大概可以确定ArrayList的大小范围下，可
* 以使用该构造器指定初始化长度，可以避免添加元素时扩容。提高效率。
*/
public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
        	//当传入的长度>0 时，直接就初始化elementData 
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
        	//当传入的长度=0 时，将elementData 引用指向EMPTY_ELEMENTDATA。
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
       		 //小于0抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
/**
* 默认构造器
*/
public ArrayList() {
		//直接将引用指向DEFAULTCAPACITY_EMPTY_ELEMENTDATA
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

/**
* 构造器，传入的是一个Collection集合
*/
public ArrayList(Collection<? extends E> c) {
		//将elementData 赋值为 该集合c转换后的数组。因为此时数组是满的，也就是下次添加元
		素必扩容。
        elementData = c.toArray();
       // 判断elementData.length是否等于0，并且将size赋值为elementData.length
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            //如果elementData的类型不是Object[]，将elementData 变为Object[]类型，通过数组的
            复制成 新的数组。
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            //当赋值后的elementData 的长度为0时，直接用EMPTY_ELEMENTDATA代替。
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
/**
* 将ArrayList瘦身，节省内存，就是创建新的数组elementData.length=size。
*/
public void trimToSize() {
        modCount++;
        //当size<elementData.length才进行瘦身
        if (size < elementData.length) {
        	//如果size=0时，将elementData 赋值为EMPTY_ELEMENTDATA，否则赋值数组。
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

/**
* 这个是公有方法，可以供我们调用，手动扩容。
*/
public void ensureCapacity(int minCapacity) {
		//elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA时minExpand 为0，否则
		为DEFAULT_CAPACITY（也就是10）
        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;

		//当要手动扩容的值大于minExpand时就进行扩容，但是是否真的成功扩容还要看
		ensureExplicitCapacity方法的逻辑。
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    /**
    *获取元素
    **/
public E get(int index) {
		//检查下标是否越界，跟size比，不是跟elementData.length。
        rangeCheck(index);

		//获取元素
        return elementData(index);
    }

 /**
    *设置元素
    **/
public E set(int index, E element) {
		//检查下标是否越界，跟size比，也就是只能设置已经添加了的元素。
        rangeCheck(index);
		//获取旧值
        E oldValue = elementData(index);
        //设置
        elementData[index] = element;
        //返回旧值
        return oldValue;
    }

/**
* 往最后添加元素，所以不会涉及数组元素的移动，性能高。
**/
public boolean add(E e) {
		//扩容，不一定会扩容成功。传入size+1 是新增这个元素后的size值。代码看下面。
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

private void ensureCapacityInternal(int minCapacity) {
		//扩容
        ensureExplicitCapacity(//初始化数组calculateCapacity(elementData, minCapacity));
    }

private static int calculateCapacity(Object[] elementData, int minCapacity) {
		//这里是懒加载的一种思想，因为当使用默认构造器构建ArrayList对象时，
		//会把DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值到elementData 。
		//elementData 的初始化会延时到第一次添加元素。
		
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //所以这里的逻辑是：当elementData ==DEFAULTCAPACITY_EMPTY_ELEMENTDATA，
        也就是第一次添加时，进入这里，获取10与minCapacity的较大值返回。
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //如果已经初始化了，不是第一次添加，就直接返回minCapacity
        return minCapacity;
        }


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

        // overflow-conscious code
        //当minCapacity 大于elementData.length时才进行扩容。
        if (minCapacity - elementData.length > 0)
        	//真正的扩容逻辑
            grow(minCapacity);
    }

//真正的扩容逻辑
private void grow(int minCapacity) {
        // overflow-conscious code
        //获取旧容值
        int oldCapacity = elementData.length;
        //计算新容值，旧容值得1.5倍进行扩容。
        int newCapacity = oldCapacity + (oldCapacity >> 1);

        if (newCapacity - minCapacity < 0)
        //旧容值*1.5倍后依旧不够minCapacity大，这种情况会出现在addAll方法和第一次添加没初
        始化时。进入这里。因为addAll方法进入这里扩容时，下次再添加元素必扩容。
            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);
    }

//当扩容之后要扩容的值大于MAX_ARRAY_SIZE 时调用该方法。
private static int hugeCapacity(int minCapacity) {
		//int类型的溢出时抛出异常。
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        
        //当添加元素后的size值> MAX_ARRAY_SIZE时返回int类型的最大值，否则返回
        MAX_ARRAY_SIZE
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

//判断是否存在该元素，通过indexOf方法来判断，因为要全部遍历，所以时间复杂度为O(n)，性
能较低。
public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

   //获取元素的第一个下标，因为要全部遍历，所以时间复杂度为O(n)，性能较低。
    public int indexOf(Object o) {
        if (o == null) {
        //元素为null的情况
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
        //元素为非null情况
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

//重写了clone方法，重置了modCount ，因为elementData被transient修饰，所以如果通过序列
化来克隆的话会忽略该元素，这不符合要求。所以不能通过序列化来克隆。
  public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            //赋值新的数组
            v.elementData = Arrays.copyOf(elementData, size);
            //重置modCount 
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }
/**
*插入元素，涉及到数组原始的移动，效率较低
**/
public void add(int index, E element) {
		//检查index是否越界 大于size或小于0就抛异常。
        rangeCheckForAdd(index);

		//扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //通过数组的复制来进行元素的后移，效果是index（包括）及之后的元素全部往后移一位。
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

/**
*删除元素涉及到数组元素的移动，效率较低
**/
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);
         //将最后一个元素赋值null，使得下次gc可以回收到他的内存。
         //假如index=2，数组为 5 4 3 2 1 null null  移动后  5 4 2 1 1 null null ,移动后要把最后一个
         元素1赋值null。
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

/**
*删除特定元素，要遍历，所以效率为较低，时间复杂度O（1）
**/
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;
    }

/**
*  清空ArrayList
**/
public void clear() {
        modCount++;

        // clear to let GC do its work
        //遍历每个元素置null。
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

/**
*添加一个集合
**/
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;
    }