ArrayList

先来一个ArrayList压压惊

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    //初始容量为10
    private static final int DEFAULT_CAPACITY = 10;
    //用于空实例的共享空数组实例。 
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //用于默认大小的空实例的共享空数组实例。我们将其与空元素数据区分开，以知道何时添加第一个元素。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //1、存放数据的数组
    //2、ArrayList的容量是这个数组缓冲区的长度。任何空的ArrayList（elementData==DEFAULTCAPACITY_empty_elementData）
    //3、当添加第一个元素时，将扩展到默认的容量- DEFAULT_CAPACITY
    transient Object[] elementData
    //数组容量  长度
    private int size;
    //数组每次的修改都会给这个值+1，用来在进行并发修改时，判断是否可以正常进行
    protected transient int modCount = 0;
    
    
    //构造函数  如果指定了长度就用指定的  没指定，就用默认的长度
    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() {
       //默认是一个空数组
       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    //可以将传入的集合的值copy给本数组对象
    public ArrayList(Collection<? extends E> c) {
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                //底层调用System.arraycopy()来进行copy  这是一个native方法
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // 初始化数组
            elementData = EMPTY_ELEMENTDATA;
        }
    }
    
    //获取指定值在数组中的下标  采用迭代去对比判断  所有的获取给定值在数组中的索引都是通过迭代去找的
    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 Object clone() {
        try {
            //调用object类的clone方法去拿到一个对象实例
            ArrayList<?> v = (ArrayList<?>) super.clone();
            //将本数组中的数据copy到克隆好的数组中
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            //返回克隆好的对象
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }
    
    public Object[] toArray() {
        //底层会创建新的数组
        return Arrays.copyOf(elementData, size);
    }
    
    //获取指定下标的数组元素
    public E get(int index) {
        //数组下标检查
        rangeCheck(index);
        return elementData(index);
    }
    private void rangeCheck(int index) {
        //给定下标大于数组长度，抛出数组下标越界异常
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    
    //给指定位置设置指定的值
    public E set(int index, E element) {
        //数组下标检查
        rangeCheck(index);
        //直接新值替换旧值，并返回旧值
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
    
    //添加元素（1）
    public boolean add(E e) {
        //生成新数组，将原来的值copy过去   见下方法的解释
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //数组长度+1，并且将给定的值放在数组最后一个位置
        elementData[size++] = e;
        return true;
    }
    
    //见下方法的解释  入参：添加元素需要的数组的最小的长度minCapacity
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    //计算数组的容量
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        //当第一次添加元素的时候，本对象（调用add（E e）这个方法的ArrayList）的下面两个数组中元素都是空数组，会进入if判断里面
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //比较默认的容量与传入的值那个大，并返回较大的值
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //不是第一次添加元素，那么直接返回传入的容量
        return minCapacity;
    }
    //计算出数组容量之后，在执行下面这个方法
    private void ensureExplicitCapacity(int minCapacity) {
        //这个值目前还没体现出作用,只是每次添加元素的时候，他的值都会+1
        modCount++;
        // overflow-conscious code
        //计算出来的新的容量是否大于远数组的容量
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    //copy原数组的内容到新生成的数组中
    private void grow(int minCapacity) {
        // overflow-conscious code
        //获取原数组容量
        int oldCapacity = elementData.length;
        //计算出新的容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果上一步计算出来的容量比（原数组容量+1）小，那么将（原数组容量+1）赋值给新容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果新的容量比 Integer.MAX_VALUE - 8 大 那么就重新设置容量
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        //生成出新的数组，并将以前的数据copy进去，并设置为默认的数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    //当计算出来的数组容量 > Integer.MAX_VALUE - 8 重新计算容量  入参的值是添加元素之前的数组长度+1
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
            //如果最小的容量也大于 Integer.MAX_VALUE - 8 那么就返回 Integer.MAX_VALUE作为计算出的容量，否则返回 Integer.MAX_VALUE - 8
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    
    //至此，一个参数的add方法结束
    
    //给指定位置添加元素
    public void add(int index, E element) {
        //判断索引是否大于0并且小于数组的长度
        rangeCheckForAdd(index);
        //这里跟上面的校验的逻辑一样 生成新数组，将原来的值copy过去
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将数组的第index个索引以及后面的全部的值都往后挪一个单位，腾出index这个索引，用来存放新的指定的值
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        //给指定索引进行赋值
        elementData[index] = element;
        //数组长度+1
        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，并且将数组的长度-1
        elementData[--size] = null; // clear to let GC do its work
        //返回移除的数
        return oldValue;
    }
    
    //移除指定的元素  
    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;
    }
    //这个也就是移除指定索引的元素了   与上面的remove方法基本一样
    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; // clear to let GC do its work
    }
    
    //清空数组
    public void clear() {
        modCount++;
        //遍历，将数组中每一项都设置为null
        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;
        //将数组长度设置为0
        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;
    }
    
    //从指定位置添加给定的集合
    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)
            //将原数组的index下标之后的数据全部挪到index+numnew之后
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
        //将给定数据的数据从index开始复制到本数组
        System.arraycopy(a, 0, elementData, index, numNew);
        //设置数组长度
        size += numNew;
        return numNew != 0;
    }
    
    //移除给定索引之间的数据
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        //计算需要挪动的数据数量
        int numMoved = size - toIndex;
        //将toIndex之后的所有数据复制到fromIndex及之后的位置
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);
    
        // clear to let GC do its work
        //计算新的数组长度，并将超度新长度的索引的数据置为null
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }
}