ArrayList扩容机制

ArrayList

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    //序列号ID，用于进行序列化和反序列化时，进行比较
    private static final long serialVersionUID = 8683452581122892189L;
    //初始化容量
    private static final int DEFAULT_CAPACITY = 10;
    //共享的空实例数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //区别于EMPTY_ELEMENTDATA，当添加第一个元素时，知道膨胀多少
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //缓存数组，存储ArrayList的元素，ArrayList的容量大小就是数组的长度，
    //任何空的ArrayList的elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
    //都会在添加第一个元素的时候拓展到DEFAULT_CAPACITY
    //transient关键字修饰的变量不参与序列化
    transient Object[] elementData;
    //ArrayList的大小
    private int size;
    
    //指定容量大小的构造函数
    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);
        }
    }
    //空构造
    public ArrayList() {
        //当添加时，容量为默认初始容量10
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    //参数为E或其子类的集合类 E是ArrayList的泛型
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
    
    //去掉elementData中的空余
    public void trimToSize() {
        //修改次数+1
        modCount++;
        //如果当前大小小于容量
        if (size < elementData.length) {
            elementData = (size == 0)
                //如果size == 0;将elementData设置为空数组对象
              ? EMPTY_ELEMENTDATA
                //否则通过copyOf自己，传入要copy的长度实现删除多余的空位
              : Arrays.copyOf(elementData, size);
        }
    }
	//确保容量
    private void ensureCapacityInternal(int minCapacity) {
            //如果elementData是默认容量的空数组
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //将默认容量和给定容量的较大值赋给最小容量
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //确保确定的容量
        ensureExplicitCapacity(minCapacity);
    }
    
    //ensureCapacityInternal调用这个方法来扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            //调用grow方法
            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)
            //就把最小容量赋值给新的容量
            newCapacity = minCapacity;
        //如果容量大于最大容量，为Integer.MAX_VALUE - 8(整型的最大容量-8)
        //为什么不直接是最大容量呢？ 一些虚拟机保存了头字段在数组中
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        /*Arrays.copyOf底层会调用System.arraycopy
        public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
                                    
         参数：  src: 源对象，及被copy的对象
         		srcPos: 从哪里开始复制
         		dest: 目的对象
         		destPos: 从哪里开始接收
         		length: 源对象要复制的长度
        通过srcPos 和 length就可以确定将源对象复制的区间
        */
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
    //当最大容量不够用的时候，还是会将整个Integer的最大值作为ArrayList的容量
    //如果这都不够的话，就抛出OutOfMemoryError()内存不足
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    
    //add 和 addAll 都会是否触发扩容的判断
    public boolean add(E e) {
        /*当第一次使用add时，size为0,则传入ensureCapacityInternal
        方法中的minCapacity为1,如果此时是默认容量的空数组，则会将1和默
        认容量进行比较，将较大值（也就是10）重新赋值给minCapacity，这就
        完成了第一次添加时的初始化容量
        */
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
    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中的元素通过copyOf放入Object[]返回
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }
    
    //获取传入对象在ArrayList的下标
    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;
        }
        //未找到返回-1
        return -1;
    }
    
    //实现和indexOf一样，但是是从数组的后往前遍历
    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 clone() {
        try {
            //super.clone 及Object中的本地方法clone
           /*
           	返回的类型为调用方法的实例对象本身
           */
            ArrayList<?> v = (ArrayList<?>) super.clone();
            //通过复制进行克隆
            v.elementData = Arrays.copyOf(elementData, size);
            //修改次数置为0
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e);
        }
    }