ArrayList公共构造函数-“构造一个初始容量为10的空列表”-在哪里？[副本]

Question

请注意，它不是为什么要以初始容量启动 ArrayList 的副本？

查看java.util.ArrayList类的源代码，至少从java1.8开始，我看到以下代码：

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

在哪里

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

尽管javadoc官方声明:

构造一个初始容量为10的空列表。

我概述：。。。初始容量为10。这十点在哪里？

我是否完全生气并错过了什么，或者这里只是一个javadoc错误？

UPD：它看起来像之前的java 1.8：

public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
}

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

Answer 1

第一次向列表中添加元素时，容量将设置为10。

看这个:

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

完整的程序

第1步：

public boolean add(E e) {
    modCount++;
    add(e, elementData, size);
    return true;
}

第2步：

private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

步骤3，列表< code >增长:

private Object[] grow() {
    return grow(size + 1); // size is 0 here
}

private Object[] grow(int minCapacity) {
    return elementData = Arrays.copyOf(elementData,
                                       newCapacity(minCapacity));  // newCapacity(1) will return 10, see step 4, the elementData will have capacity 10.
}

第4步，调用newSpace（1）：

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);   // will  return 10 here !!!!
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return minCapacity;
    }
    return (newCapacity - MAX_ARRAY_SIZE <= 0)
        ? newCapacity
        : hugeCapacity(minCapacity);
}

Answer 2

这是一种优化。开发人员决定用一个空的支持数组初始化＜code＞ArrayList＜/code＞，只有当您开始向＜code＞List＜/code>添加元素时，才惰性地创建一个非空的支持阵列。

当您添加第一个元素（通过调用＜code＞add＜/code＞）时，它会调用

ensureCapacityInternal(size + 1);

检查元素数据 == DEFAULTCAPACITY_EMPTY_ELEMENTDATA，如果是，则将容量设置为

minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

DEFAULT_CAPACITY是 10。