Jtdylktuy

Be aware, it is not a duplicate of Why start an ArrayList with an initial capacity?

Looking into the source code of the java.util.ArrayList class, starting from at least java 1.8 I see the following code:

/**

 * Constructs an empty list with an initial capacity of ten.

 */

public ArrayList() {

    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

}

Where

private static final Object DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

Though the javadoc officially states:

Constructs an empty list with an initial capacity of ten.

I outline: ...an initial capacity of ten. Where is this ten?

Am I completely mad and missing something, or there is simply a javadoc bug here?

UPD: How it looked like prior 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);

}

This is an optimization. The developers decided to initialize the ArrayList with an empty backing array, and lazily create a non-empty backing array only when you start adding elements to the List.

When you add the first element (by calling add), it calls

ensureCapacityInternal(size + 1);

which checks if elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA, and if so, sets the capacity to

minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

DEFAULT_CAPACITY is 10.

The capacity will be set as 10 when you add element to the list first time.

See this:

/**

 * Default initial capacity.

 */

private static final int DEFAULT_CAPACITY = 10;

Complete procedure

Step 1:

public boolean add(E e) {

    modCount++;

    add(e, elementData, size);

    return true;

}

Step 2:

private void add(E e, Object elementData, int s) {

    if (s == elementData.length)

        elementData = grow();

    elementData[s] = e;

    size = s + 1;

}

Step 3, the list grows:

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.

}

Step 4, call newCapacity(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);

}