Why does Enumeration get converted to ArrayList and not List in java.utils?

Question

Is there a good reason that the Collections.list() method in the java.utils package returns an ArrayList<T> instead of List<T>?

Obviously an ArrayList is a List, but I'm under the impression that it's generally good practice to return the interface type instead of implementation type.

Answer 1

Disclaimer: I am not a JDK author.

I agree that it's correct to write your own code to interfaces, but if you're going return a mutable collection to a third party, it's important to let the third party know what sort of List they're getting back.

LinkedList and ArrayList are very different, performance wise, for various operations. For example, removing the first element of an ArrayList is O(n), but removing the first element of a LinkedList is O(1).

By fully specifying the return type, the JDK authors are communicating extra information, in unambiguous code, about what sort of object they're giving back to you, so you can write your code to use this method properly. If you really need a LinkedList, you know that you have to specify one here.

Finally, the main reason to code to an interface over an implementation is if you think that the implementation will change. The JDK authors probably figure they are never going to change this method; it's never going to return a LinkedList or a Collections.UnmodifiableList. However, in most cases, you would probably still do:

List<T> list = Collections.list(enumeration);