Why use Collection.empty[T] instead of new Collection[T]()

Question

I was wondering if there is a good reason to use Collection.empty[T] instead of new Collection[T]() (or the inverse) ? Or is it just a personal preference ?

Thanks.

Answer 1

Calling new Collection[T]() will create a new instance every time. On the other hand, Collection.empty[T] will most likely always return the same singleton object , usually defined somewhere as

object Empty extends Collection[Nothing] ...

which will be much faster. Edit: This is only possible for immutable collections, mutable collections have to return a new instance every time empty is called.

Answer 2

您应该始终喜欢Collection.empty[Type] 。

Answer 3

In addition to Collection.empty[T] being clearer on the intent, you should favour it for the same reason that you should favour factory methods in general when instantiating a collection: because thoses factories abstract away some implementation details that you might not (or should not) care about. By example, when you do Seq.empty[String] you actually get an instance of List[String] . You could directly instantiate a List[String] but if all you care about is to have some Seq you would introduce a needless dependency to List (well OK, actually you cannot as it stands, because List is already abstract, but let's pretend we can for the sake of the argument) The whole point of factories is precisely to have some amount of separation of concern and not bother with unnecessary instantiation details.

As another more elaborate example, let's talk about collection.immutable.HashMap . This one is very much a concrete class so you might think there is no need for a factory here. Except that for optimization purpose the factory in the companion object collection.immutable.HashMap will actually create different sub-classes depending on the number of elements that you initialize the map with (see this question: Scala: how to make a Hash(Trie)Map from a Map (via Anorm in Play) ). Obviously, if you directly instantiate collection.immutable.HashMap you will lose this optimization.

Another common optimization for empty is to always return (when it is an immutable collection) the same instance, yet another useful optimization that you would lose by directly instantiating the collection.

So as a rule of thumb, as far as you can you should use the factories that are provided by the various collection companion objects, so as to shield yourself from unneeded dependencies while at the same time benefiting from potential optimizations provided by the collection framework.

empty is just a special case of factory, and so the same logic applies.