In Java 8, why is the default capacity of ArrayList now zero?

Question

As I recall, before Java 8, the default capacity of ArrayList was 10.

Surprisingly, the comment on the default (void) constructor still says: Constructs an empty list with an initial capacity of ten.

From ArrayList.java:

/**  * 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 = {};  ...  /**  * Constructs an empty list with an initial capacity of ten.  */ public ArrayList() {     this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } 

Answer 1

Technically, it's 10, not zero, if you admit for a lazy initialisation of the backing array. See:

public boolean add(E e) {     ensureCapacityInternal(size + 1);     elementData[size++] = e;     return true; }  private void ensureCapacityInternal(int minCapacity) {     if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {         minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);     }      ensureExplicitCapacity(minCapacity); } 

where

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

What you're referring to is just the zero-sized initial array object that is shared among all initially empty ArrayList objects. I.e. the capacity of 10 is guaranteed lazily, an optimisation that is present also in Java 7.

Admittedly, the constructor contract is not entirely accurate. Perhaps this is the source of confusion here.

Background

Here's an E-Mail by Mike Duigou

I have posted an updated version of the empty ArrayList and HashMap patch.

http://cr.openjdk.java.net/~mduigou/JDK-7143928/1/webrev/

This revised implementation introduces no new fields to either class. For ArrayList the lazy allocation of the backing array occurs only if the list is created at default size. According to our performance analysis team, approximately 85% of ArrayList instances are created at default size so this optimization will be valid for an overwhelming majority of cases.

For HashMap, creative use is made of the threshold field to track the requested initial size until the bucket array is needed. On the read side the empty map case is tested with isEmpty(). On the write size a comparison of (table == EMPTY_TABLE) is used to detect the need to inflate the bucket array. In readObject there's a little more work to try to choose an efficient initial capacity.

From: http://mail.openjdk.java.net/pipermail/core-libs-dev/2013-April/015585.html

Answer 2

In java 8 default capacity of ArrayList is 0 until we add at least one object into the ArrayList object (You can call it lazy initialization).

Now question is why this change has been done in JAVA 8?

Answer is to save memory consumption. Millions of array list objects are created in real time java applications. Default size of 10 objects means that we allocate 10 pointers (40 or 80 bytes) for underlying array at creation and fill them in with nulls. An empty array (filled with nulls) occupy lot of memory .

Lazy initialization postpones this memory consumption till moment you will actually use the array list.

Please see below code for help.

ArrayList al = new ArrayList();          //Size:  0, Capacity:  0 ArrayList al = new ArrayList(5);         //Size:  0, Capacity:  5 ArrayList al = new ArrayList(new ArrayList(5)); //Size:  0, Capacity:  0 al.add( "shailesh" );                    //Size:  1, Capacity: 10  public static void main( String[] args )         throws Exception     {         ArrayList al = new ArrayList();         getCapacity( al );         al.add( "shailesh" );         getCapacity( al );     }      static void getCapacity( ArrayList<?> l )         throws Exception     {         Field dataField = ArrayList.class.getDeclaredField( "elementData" );         dataField.setAccessible( true );         System.out.format( "Size: %2d, Capacity: %2d%n", l.size(), ( (Object[]) dataField.get( l ) ).length ); }  Response: -  Size:  0, Capacity:  0 Size:  1, Capacity: 10 

Article Default capacity of ArrayList in Java 8 explains it in details.