Why insertion into empty ArrayList takes more time than insertion into non-empty ArrayList?

Question

I ran my profiler program for 1000 iterations to calculate the average time taken to insert into Empty ArrayList and average time to insert into Non-Empty ArrayList. I ran my profiler program for ArrayList<Item>, where Item class is

class Item{
  int id;
  String name;
}

And the profiler program is something like

main(){
  final int iterations = 1000;

  /**** Empty List Insert ****/
  int id = 0;
  long[] timerecords = new long[iterations];
  ArrayList<Item> list = new ArrayList<>();
  for (int i = 0; i < iterations; i++) {
      long stime = System.nanoTime(); //Start Time
      list.add(new Item(id, "A"));
      long elapsedTime = System.nanoTime() - stime; //Elapsed time
      timerecords[i] = elapsedTime; //Record Elapsed time

      //reset
      list.clear();
  }
  System.out.println("Empty List Insert Takes = " + getAverageTime(timerecords) + " nanoseconds");

  /**** Non-Empty List Insert ****/
  list = new ArrayList<>();
  timerecords = new long[iterations];
  //Insert some Items
  list.add(new Item(id++, "B")); list.add(new Item(id++, "R"));
  list.add(new Item(id++, "H")); list.add(new Item(id++, "C")); 

  for (int i = 0; i < iterations; i++) {    
        Item item = new Item(id, "A");
        long stime = System.nanoTime(); //Start Time
        list.add(item);
        long elapsedTime = System.nanoTime() - stime; //Elapsed time
        timerecords[i] = elapsedTime; //Record Elapsed time

        //reset
        list.remove(item);
  }
  System.out.println("Non-Empty List Insert Takes = " + getAverageTime(timerecords) + " nanoseconds");
}

where getAverageTime(long [] timerecords) method returns average time in double. After running this program several times, I observed insertion into empty ArrayList takes more time than insertion into non-empty ArrayList. One such run output is

Empty List Insert Takes = 1027.781 nanoseconds
Non-Empty List Insert Takes = 578.825 nanoseconds

Whats the reason behind this ?

Answer 1

The difference comes because of the instance creation (new Item()).

  long stime = System.nanoTime(); //Start Time
  list.add(new Item(id, "A")); // at this point two things are happening
  // creation of instance & addition into ArrayList
  // both takes their own time.

  long elapsedTime = System.nanoTime() - stime; //Elapsed time

The point where u create stime variable is the point where the timer starts. You are certainly adding new item to the list. But in 1st case, before u do System.nanoTime(); u are calling new operator on Item while adding (after you assign stime variable) which is taking that extra time. While in 2nd case, you are doing it before u r doing System.nanoTime();

    Item item = new Item(id, "A");
    long stime = System.nanoTime(); //Start Time
    list.add(item);
    long elapsedTime = System.nanoTime() - stime; //Elapsed time

so, only adding of item object to the ArrayList time is captured.

Answer 2

If you look into the implementation of ArrayList - an empty ArrayList starts with a an empty array to store the data - thats easy.

But when you first call the add() method, this array needs to be copied - hence memory needs to be allocated. The ensureCapacity() and grow() methods try to minimize the creation of Arrays.copyOf(), but as long as the internal Array size is still small, more and more often this array has to be increased, which might lead to the increased duration.

Here's ArrayList.grow(int) from 1.7:

  private void grow(int minCapacity) {
    int oldCapacity = this.elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if(newCapacity - minCapacity < 0) {
      newCapacity = minCapacity;
    }

    if(newCapacity - 2147483639 > 0) {
      newCapacity = hugeCapacity(minCapacity);
    }

    this.elementData = Arrays.copyOf(this.elementData, newCapacity);
  }

You didn't measure the time a creation of an non-empty ArrayLIst takes, did you?

Answer 3

I was interested, so I did some debugging on it. The effect comes from two separate sources:

As @Alexander already pointed out, constantly increasing the capacity of the Arraylist size comprimises your test. To "fix" this, you can just create your ArrayLists with sufficient provision, like:

ArrayList<Item> list = new ArrayList<>(iterations * 2);

Even after doing this one can observe a difference of 100-300% in performance between your first and second test case. The reason for that is related to Java internals, namely ClassLoading and JIT. By doing a warmUp round before your first test, something like this:

    int rounds = 10000;
    long[] t = new long[rounds];
    ArrayList<Item> warmUpList = new ArrayList<>(rounds);
    for (int i = 0; i < rounds; i++) {
        warmUpList.add(new Item(0, "A"));
        long stime = System.nanoTime(); // Start Time
        long elapsedTime = System.nanoTime() - stime; // Elapsed time
        t[i] = elapsedTime; // Record Elapsed time
    }

You can play with the optimizer. By increasing the value of the "round" variable from 100 to 10.000 you can see how your own tests are getting better and better performance, and than stabilizing at an equivalent speed.

Answer 4

Mesuring each single insertion using System.nanoTime() can results in non reliable values. It is better to do the same with System.currentTimeMillis() and mesuring the whole loop.

In addition the insert time in an ArrayList can be influenced on how many grows of the internal array are performed. So inserting in an empty ArrayList with a small internal array can results in many grows. Inserting in a non empty ArrayList with a partially empty big internal array can result in no grows, but if grows happens it is slower than for an empty array because you have to copy bigger arrays.