Best Way to use ArrayList in Java

                     In the following post we are goning to discuss a little variation in use of ArrayList in java. We will see how we can improve the performance by just a small change. First of all run the below java code on your machine.

import java.util.ArrayList;
import java.util.List;

public class Test{
 
 public static void main(String... args) {

  int s = 10000000;
  String v = "PROGRAMMING";
  long t1,t2;

  //Segment-1
  t1 = System.currentTimeMillis();
  List<String> l1 = new ArrayList<>();
  for(int i=0; i<s; ++i){
   l1.add(v);
  }
  t2 = System.currentTimeMillis();
  System.out.println("Time for above segment-1 : "+(t2-t1)+" ms");

  //Segment-2
  t1 = System.currentTimeMillis();
  List<String> l2 = new ArrayList<>(s);
  for(int i=0; i<s; ++i){
   l2.add(v);
  }
  t2 = System.currentTimeMillis();
  System.out.println("Time for above segment-2 : "+(t2-t1)+" ms");
 }

}

I executed it on my machine and got the following result. I hope you would also got the similar output.

Time for above segment-1 : 115 ms
Time for above segment-2 : 39 ms

Despite the execution time difference between the two code segments. You will always found that time taken by segment-1 is greater than segment-2. If you will look both code segments carefully You will find only one minute difference in Constructor. In the first segment: No argument in constructor

List<String> l1 = new ArrayList<>();

In the second segment: Capacity passed in constructor

List<String> l1 = new ArrayList<>(s);

When We don't pass capacity in ArrayList it initialize with capacity=10. Every time the ArrayList reached to limit It has to resize the array. There is a grow() method used in ArrayList.java class to expand the array. Internal logic of the grow() method

(1) newCapacity = oldCapacity + (oldCapacity/2)
(2) create a new array of newCapcity.
(3) Copy the elements of old Array to new Array.

The below code snipet are from the ArrayList.java class

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

/**
* 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
*/
private void grow(int minCapacity) {
 // overflow-conscious code
 int oldCapacity = elementData.length;
 int newCapacity = oldCapacity + (oldCapacity >> 1);
 if (newCapacity - minCapacity < 0)
     newCapacity = minCapacity;
 if (newCapacity - MAX_ARRAY_SIZE > 0)
     newCapacity = hugeCapacity(minCapacity);
 // minCapacity is usually close to size, so this is a win:
 elementData = Arrays.copyOf(elementData, newCapacity);
}
 

So every time the ArrayList reach to limit, costly operation grow() method called. If you have an estimate of capacity of list requirement, you can pass it as argument in the constructor of ArrayList.