介绍

今天在Review代码的时候，发现同事定义的ArrayList实例是new ArrayList(0)，然而我平常写的时候都是直接new ArrayList()，那么两者有什么区别呢？我们一起走进源码看看。

/**
 * Default initial capacity.
*/
    private static final int DEFAULT_CAPACITY = 10;

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);
        }
    }

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

可以看到两种创建单例的方式，内部的数组是两个EMPTY_ELEMENTDATA和DEFAULTCAPACITY_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 = {};

表面上看起来都是长度为0的数组，但请认真看DEFAULTCAPACITY_EMPTY_ELEMENTDATA的注释：
/**

• 分享一个弄得数组对象被用来作为默认长度的空对象，它和EMPTY_ELEMENTDATA
• 分开表示用来了解添加第一个元素的应该扩容多大。
  */

那么我们就看看添加第一个元素的时候，源码是怎么处理的？

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

 private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

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

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

添加第一个元素的时候ensureCapacityInternal中的minCapacity=1，该方法的内部判断当elementData是DEFAULTCAPACITY_EMPTY_ELEMENTDATA的时候，minCapacity取DEFAULT_CAPACITY和minCapacity的最大值即10。也就是说如果我们使用new ArrayList()的时候，当添加第一个元素的时候，数组长度直接扩容到10，如果我们使用new ArrayList(0)的时候，当添加第一个元素的时候，数组长度直接扩容到1。

总结

有人会说，那我们平时使用new ArrayList()也没多大影响啊！假设现在JVM的堆内存只有10Byte的大小，那么我们使用new ArrayList<Byte>(),当添加第一个元素的时候，数组就要扩容到10Byte的容量。如果堆内存是通过标记清除算符GC后剩余的10Byte的大小 ，此时的内存上的可用内存不是连续的空间，我们在创建数组的时候，数组是需要一块连续的内存的，即此时内存不足以分配连续的10Byte内存，就会导致内存异常。所以我们在性能优化的时候，任何细节都要注意。