List实现类之ArrayList构造方法源码分析

1 ArrayList

1.1 ArrayList()

1、官方注释：Constructs an empty list with an initial capacity of ten，构造一个初始化容量为10的空集合；

2、源码如下：（只列出了需要的）

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
        private static final Object[] EMPTY_ELEMENTDATA = {};
        // 初始化容量大小
        private static final int DEFAULT_CAPACITY = 10;
        // 记录集合修改的次数，iterator会用到
        protected transient int modCount = 0;
        // 记录集合中元素的数量
        private int size;
        /**
         * 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.
        */
        private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
        transient Object[] elementData; // non-private to simplify nested class access
        /**
         * Constructs an empty list with an initial capacity of ten.
         */
       	public ArrayList() {
            this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
        }
}

3、通过源码可以看到，在调用无参构造方法时，只是把DEFAULTCAPACITY_EMPTY_ELEMENTDATA空数组赋值给elementData，并没有体现出容量为10；

4、 通过无参构造方法创建的ArrayList，会在添加第一个元素时将集合的容量初始化为10；

5、众所周知，集合的老祖宗Collection提供了boolean add(E e);方法，用于向集合中添加元素，我们来看一下ArrayList中的add方法

	// 该方法是对其父接口List中add方法的实现，但源头是Collection中的add方法
    public boolean add(E e) {
          ensureCapacityInternal(size + 1);  // Increments modCount!!
          elementData[size++] = e;
          return true;
    }

	// add方法中调用的第一个方法 
    private void ensureCapacityInternal(int minCapacity) {
        // 使用无参构造方法创建的集合，在容量没有发生改变时，会和默认容量大小（DEFAULT_CAPACITY）进行比较
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        
        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
		// 第一次调用add方法时，minCapacity = 10（ensureCapacityInternal方法中确定的）
        // elementData.length=0，所以会进行一次扩容
        // overflow-conscious code（下面的代码考虑了溢出，关于溢出的内容后面再分享）
        if (minCapacity - elementData.length > 0)
            // 扩容
            grow(minCapacity);
    }

	// 该方法实现了扩容（将旧数组中的元素复制到一个新数组中，关于集合的扩容机制，后面分享）
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;	// 第一次扩容时：0
        int newCapacity = oldCapacity + (oldCapacity >> 1);	// 右移位运算
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        // ******使用无参构造方法创建的ArrayList，在此处实现了集合容量初始化为10***
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

6、总结：

​ 通过无参构造方法public ArrayList();创建一个集合，在创建后，集合的容量为0，在第一次添加元素时，会进行一次扩容，将集合的容量扩充到10。

1.2 ArrayList(int initialCapacity)

1、源码

    // 创建一个指定容量的集合
	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);
        }
    }

2、分析

（1）当指定容量大于0时，会直接创建一个指定容量大小的数组；

（2）当指定容量为0时，给elementData赋值一个空数组EMPTY_ELEMENTDATA

    /**
     * Shared empty array instance used for empty instances.
     */
    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.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

在jdk1.8的源码中，存在这样两个数组，除了名字，其他都一样，那么为什么要定义两个属性呢？查了一下资料，说是相较于1.7进行的优化，减少了空数组的存在，目前还存在疑问。

（3）当使用有参构造函数创建的集合调用add方法时

	// add方法中调用的第一个方法 
    private void ensureCapacityInternal(int minCapacity) {
        // 有参构造函数创建的集合，一直false，会直接走下面的逻辑
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        
        ensureExplicitCapacity(minCapacity);
    }

3、总结

​ ArrayList的底层数据结构为数组，要实现扩容，需要将原来素组中的元素一一复制到新的更大的数组中，消耗资源，所以，如果在使用ArrayList前可以确定集合的容量，推荐使用public ArrayList(int initialCapacity) {}，避免在第一次添加元素时就进行扩容操作。

1.3 ArrayList(Collection<? extends E> c)

	// 将传入的参数转换为ArrayList类型
	public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }