ArrayList源码分析

ArrayList源码分析

ArrayList继承结构

• extends AbstractList ：继承了AbstractList。为什么要先继承AbstractList，而让AbstractList先实现List？而不是让ArrayList直接实现List？
  • 这里是有一个思想，接口中全都是抽象的方法，而抽象类中可以有抽象方法，还可以有具体的实现方法，正是利用了这一点，让AbstractList实现接口中一些通用的方法，而具体的类， 如ArrayList就继承这个AbstractList类，拿到一些通用的方法，然后自己在实现一些自己特有的方法，这样一来，让代码更简洁，就继承结构最底层的类中通用的方法都抽取出来，先一起实现了，减少重复代码。所以一般看到一个类上面还有一个抽象类，应该就是这个作用。

ArrayList属性成员

	//序列号
	private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.
     * 默认的初始化容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     * 当用户指定该 ArrayList 容量为 0 时，返回该空数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     * 当调用无参构造方法，返回的是该数组。刚创建一个ArrayList 时，其内数据量为0
     * 它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，而EMPTY_ELEMENTDATA是在用户指定容量为0时返回。
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     * 保存添加到ArrayList中的元素。
     * 该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入ArrayList中时，数组将扩容值DEFAULT_CAPACITY。
     * 被标记为transient，在对象被序列化的时候不会被序列化。
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     * ArrayList的实际大小
     */
    private int size;

ArrayList构造方法

//initialCapacity为传入的list的初始化容量
public ArrayList(int initialCapacity) {
    	//初始容量大于0,实例化数组，将自定义的容量大小当成初始化elementData的大小
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        //初始容量等于0，将空数组EMPTY_ELEMENTDATA赋给elementData
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        //初始容量小于0，抛异常
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

//构造一个初始容量为10的空列表
//当元素第一次被加入时，扩容至默认容量 10
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

//构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的
public ArrayList(Collection<? extends E> c) {
    	//将集合转换成Object数组
        Object[] a = c.toArray();
    	//把转化后的Object[]数组长度赋值给当前ArrayList的size，并判断是否为0
        if ((size = a.length) != 0) {
            //判断传入的Collection的类型是否是ArrayList类型，如果是就直接赋值给elementData
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            //如果不是，则利用 Arrays.copyOf(); 来构造一个大小为 size 的 Object[] 数组
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            //替换为空数组
            elementData = EMPTY_ELEMENTDATA;
        }
    }

ArrayList主要方法

set()方法

//用指定的元素替换列表中指定位置的元素
public E set(int index, E element) {
    	检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常
        rangeCheck(index);
    	//保存被替换的值（旧值）
        E oldValue = elementData(index);
    	//替换元素，将传入的值替换到旧值的位置
        elementData[index] = element;
    	//返回被替换的值
        return oldValue;
    }

add()方法

//将指定的元素追加到此列表的末尾
public boolean add(E e) {
    	//确认list容量
        ensureCapacityInternal(size + 1);  // Increments modCount!!
    	//将元素e放在size的位置上,并且size++
        elementData[size++] = e;
        return true;
    }

//数组容量检查，不够时则进行扩容，只供类内部使用 
private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

// 若elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则取minCapacity为DEFAULT_CAPACITY和参数minCapacity之间的最大值。DEFAULT_CAPACITY在此之前已经定义为默认的初始化容量是10。
private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

//数组容量检查，不够时则进行扩容，只供类内部使用 
// minCapacity 想要的最小容量
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        // 最小容量>数组缓冲区当前长度
        if (minCapacity - elementData.length > 0)
            //扩容
            grow(minCapacity);
    }

private void grow(int minCapacity) {
		//获取当前数组的容量
        int oldCapacity = elementData.length;
    	//扩容。新的容量=当前容量+当前容量/2。即将当前容量增加一半（当前容量增加1.5倍）。
        int newCapacity = oldCapacity + (oldCapacity >> 1);
    	如果扩容后的容量还是小于想要的最小容量
        if (newCapacity - minCapacity < 0)
            //将扩容后的容量再次扩容为想要的最小容量
            newCapacity = minCapacity;
    	//如果扩容后的容量大于临界值，则进行大容量分配
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
		//新的容量大小已经确定好了，就copy数组，改变容量大小。
    	//copyof(原数组，新的数组长度)
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

//进行大容量分配
private static int hugeCapacity(int minCapacity) {
    	//如果minCapacity<0，抛出异常
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
    	//如果想要的容量大于MAX_ARRAY_SIZE，则分配Integer.MAX_VALUE，否则分配MAX_ARRAY_SIZE
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

public void add(int index, E element) {
    	//越界检查
        rangeCheckForAdd(index);
    	//确认list容量
        ensureCapacityInternal(size + 1);  // Increments modCount!!
    	// 对数组进行复制处理，目的就是空出index的位置插入element，并将index后的元素位移一个位置
		//在插入元素之前，要先将index之后的元素都往后移一位
    	//arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制的数组元素的数量)
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
    	//将指定的index位置赋值为element
        elementData[index] = element;
    	//实际容量+1
        size++;
    }


private void rangeCheckForAdd(int index) {
    	//插入的位置不能大于size 和小于0，如果是就报越界异常
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

get()方法

//返回list中指定位置的元素
public E get(int index) {
    	//越界检查
        rangeCheck(index);
        return elementData(index);
    }

private void rangeCheck(int index) {
    	//索引index>=size，抛出一个越界异常
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

remove()方法

//删除list中指定位置的元素
public E remove(int index) {
    	//检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常
        rangeCheck(index);
    	//结构性修改次数+1
        modCount++;
    	//存储索引处的元素
        E oldValue = elementData(index);
		//删除指定元素后，需要左移的元素个数
        int numMoved = size - index - 1;
    	//如果有需要左移的元素，就移动（移动后，该删除的元素就已经被覆盖了）
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
    	//size减一，然后将索引为size-1处的元素置为null。为了让GC起作用，必须显式的为最后一个位置赋null值
        elementData[--size] = null; // clear to let GC do its work
		//返回被删除的元素
        return oldValue;
    }

//删除指定元素
public boolean remove(Object o) {
    	//如果传入的指定元素为null
        if (o == null) {
            //循环遍历list中的所有元素，如果存在则删除第一个出现项并返回true
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        //如果传入的指定元素不为null
        } else {
            //循环遍历list中的所有元素，如果存在则删除第一个出现项并返回true
            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);
    	//size减一，然后将索引为size-1处的元素置为null。为了让GC起作用，必须显式的为最后一个位置赋null值
        elementData[--size] = null; // clear to let GC do its work
    }

//从该列表中删除索引位于两者之间的所有元素，包含fromIndex，但是不包含toIndex
protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
    	//索引toIndex后面的个数
        int numMoved = size - toIndex;
    	//arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制的数组元素的数量)
        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;
    }

//删除指定集合中的所有元素
public boolean removeAll(Collection<?> c) {
		//非空检查
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }


private boolean batchRemove(Collection<?> c, boolean complement) {
    	//得到元集合
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            //遍历循环list中的元素，complement传入的false
            for (; r < size; r++)
                //如果集合Collection<?> c中不包含list中当前元素
                if (c.contains(elementData[r]) == complement)
                    //则把当前元素的值重新赋值给elementData
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                //将w后面的元素赋值为null
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

indexOf()和lastIndexOf()方法

//返回此列表中指定元素的第一个出现项的索引，如果该列表不包含该元素，则返回-1。
public int indexOf(Object o) {
    	//如果查找的元素为null
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        //查找的元素不为null
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }


//返回此列表中指定元素的最后一次出现的索引，如果该列表不包含该元素，则返回-1。
public int lastIndexOf(Object o) {
    //如果查找的元素为null
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    //查找的元素不为null
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

clear()方法

//从列表中删除所有元素
public void clear() {
    modCount++;
    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    size = 0;
}