关于Java 9 中Arraylist中构造方法初始化容量为10的思考

Java 9 中Arraylist中构造方法初始化容量为10的思考

在java 9中arraylist构造方法中的 Public ArrayList()方法创建了容量为10的数组列表，
可在该方法的源码中根本没有提到创建容量为10的数组列表，曾一度怀疑没有去创建容量为10的数组列表，但JAVA前辈很难会犯这种错误，怀着好奇心，我去寻找这一答案。

首先，我直接表达结果，过程在后面，有点长，有大量源码，若是有兴趣可以仔细查看：
在使用无参arraylist的构造方法时，构造方法并没有直接将容量设为10，而是在后面调用add()方法时，在add方法中调用grow()方法，grow()中进行容量的分配，而分配的依据是通过newCapacity方法去决定的，在newCapacity方法中定义了当默认容量为： DEFAULTCAPACITY_EMPTY_ELEMENTDATA时容量设定为DFAULT_CAPACITY即容量设为10。
这样的方法的设置更好地利用的存储空间，避免了空间的浪费，也不得不感慨JAVA前辈的智慧。

具体步骤和源码

首先我们一定要相信我们的判断，无参构造方法中并没有创建容量为10的数组列表，因为无参构造方法中很明确的声明了：

this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

其中DEFAULTCAPACITY_EMPTY_ELEMENTDATA在源码文档中有定义：

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

即定义该符号为空，所以在构造方法中是一定没有创建容量为10的数组列表！
那么问题来了，是在哪里创建了容量为10的数组列表？我陷入了深深地怀疑中，难道真的是前辈们打错字了？？？，不可能啊，只能继续思考，如果不能在构造方法中去创建，那就只可能在add方法中去定义，扒出源码：

add(E e)方法的源码

/**
     *将指定的元素添加到此列表的尾部。
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }

其中 add(e,elementData,size)中的add方法源码为：

add(E e, Object[] elementData, int s)形式源码

 /**
     * This helper method split out from add(E) to keep method
     * bytecode size under 35 (the -XX:MaxInlineSize default value),
     * which helps when add(E) is called in a C1-compiled loop.
     *该方法是为了辅助函数add（e）的使用而设置的
     */
    private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }

add(int index,E element)形式源码

/**
     * Inserts the specified element at the specified position in this
     * list. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right (adds one to their indices).
     * @param index index at which the specified element is to be inserted
     * @param element element to be inserted
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        modCount++;
        final int s;
        Object[] elementData;
        if ((s = size) == (elementData = this.elementData).length)
            elementData = grow();
        System.arraycopy(elementData, index,
                         elementData, index + 1,
                         s - index);
        elementData[index] = element;
        size = s + 1;
    }

OK，源码放上去了，两种add方法的使用说明就不具体介绍了，大家应该都清楚，我们看第一种add(E e)的方法，它调用了
private void add(E e, Object[] elementData, int s) 方法，在该方法中调用了grow（）方法，同时我们也可以发现在第二种add（int index, E element）方法中存在这样的语句：

 elementData = grow();

说明数组列表的容量与grow()方法有着密切的关系，我们再扒出grow（）方法：

grow（）方法的源码

    /**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     * @throws OutOfMemoryError if minCapacity is less than zero
     */
    private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
    }

    private Object[] grow() {
        return grow(size + 1);
    }

可以看grow方法返回了elementData即：数组列表的容量；可能这里就是我们要找的答案了，这里出现了copyOf方法，它的意义是：

copyOf方法说明：

public static <T> T[] copyOf(T[] original, int newLength)
    方法说明： 复制指定的数组，截取或用 null填充（如有必要），以使副本具有指定的长度。
              对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。
               对于在副本中有效而在原数组无效的所有索引，副本将包含null。
               当且仅当指定长度大于原数组的长度时，这些索引存在。所得数组和原数组属于完全相同的类。 

    参数：
    original - 要复制的数组
    newLength - 要返回的副本的长度 
    返回：
    原数组的副本，截取或用 null 填充以获得指定的长度 
    抛出： 
    NegativeArraySizeException - 如果 newLength 为负 
    NullPointerException - 如果 original 为 null

这时我们查看newCapacity(minCapacity)的意义，这里用到了newCapacity方法，老样子，上源码！

private int newCapacity(int minCapacity)函数源码

   /**
     * Returns a capacity at least as large as the given minimum capacity.
     * Returns the current capacity increased by 50% if that suffices.
     * Will not return a capacity greater than MAX_ARRAY_SIZE unless
     * the given minimum capacity is greater than MAX_ARRAY_SIZE.
     *
     * @param minCapacity the desired minimum capacity
     * @throws OutOfMemoryError if minCapacity is less than zero
     */
    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity <= 0) {
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return minCapacity;
        }
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
    }

在这个方法里这个语句

 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
     return Math.max(DEFAULT_CAPACITY, minCapacity);

这个语句是用来处理我们遇到的问题，即add（）方法怎么去设置容量大小为10 的数组列表，在newCapacity方法中，若是

elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA

则返回DEFAULT_CAPACITY与minCapacity中较大的值，DEFAULT_CAPACITY在开始定义为10，所以这就是为啥构造函数说创建了容量为10的数组列表！

以上是我个人见解，欢迎前来讨论指正！