Performance costs of casting a concrete collection to its interface

When I write some API, it sometimes will use Collection<Model> to be the parameter. Of course, you can use ArrayList if you know ArrayList is already enough to handle all the use case.

My question is is there any considerable performance cost whe开发者_StackOverflown for example cast the ArrayList<Model> to Collection<Model> when passing parameter.

Will the collection size also impact the performance of casting? Any advice?

Thanks for Peter's answer.

I think the answer is pretty enough to stop me to waste time on changing it.

EDIT

As said in accepted answer, the cost is actually paid in the calling of interface methods. it's not free to keep this kind of flexibity. But the cost is not so considerable.

Like most performance questions the answer is; write cleare and simple code and the application usually performs okay as well.

A cast to an interface can take around 10 ns (less than a method call) Depending on how the code is optimised, it might be too small to measure.

A cast between generic types is a compiler time check, nothing actually happens at runtime.

When you cast, it is the reference type which changes, all references are the same size. The size of what they point to doesn't matter.

BTW: All ArrayList objects are the same size, All LinkedList objects are the same size all HashMap objects are the same size etc. They can reference an array which can be different sizes in different collection.

You can see a difference in code which hasn't been JITed.

public static void main(String... args) throws Throwable {
  ArrayList<Integer> ints = new ArrayList<>();
  for(int i=0;i<100;i++) ints.add(i);
  sumSize(ints, 5000);
  castSumSize(ints, 5000);
  sumSize(ints, 5000);
  castSumSize(ints, 5000);
}

public static long sumSize(ArrayList<Integer> ints, int runs) {
  long sum = 0;
  long start = System.nanoTime();
  for(int i=0;i<runs;i++)
    sum += ints.size();
  long time = System.nanoTime() - start;
  System.out.printf("sumSize: Took an average of %,d ns%n", time/runs);
  return sum;
}

public static long castSumSize(ArrayList<Integer> ints, int runs) {
  long sum = 0;
  long start = System.nanoTime();
  for(int i=0;i<runs;i++)
    sum += ((Collection) ints).size();
  long time = System.nanoTime() - start;
  System.out.printf("castSumSize: Took an average of %,d ns%n", time/runs);
  return sum;
}

prints

sumSize: Took an average of 31 ns
castSumSize: Took an average of 37 ns
sumSize: Took an average of 28 ns
castSumSize: Took an average of 34 ns

however the difference is likely to be due to the method calls being more expensive. The only bytecode difference is

invokevirtual   #9; //Method java/util/ArrayList.size:()I

and

invokeinterface #15,  1; //InterfaceMethod java/util/Collection.size:()I

Once the JIT has optimised the code there isn't much difference. Run long enough, the time drops to 0 ns for the -server JVM because it detects the loop doesn't do anything. ;)

Compared to doing anything with any object: absolutely none.

And even if it did, be sure any program involves things taking millions more time!

Collection is an interface. You always have to provide a concrete implementation such as ArrayList.

Commonly it would be this

Collection<Model> myCollection = new ArrayList<Model>();

Designing to interfaces is actually good practice, so use Collection as your method parameter.