It can't be related to performance, actually: All the methods delegate to the same creation method, which expects an array anyhow.
My guess is that it is related to warnings. Consider the following, minimal snippet:
import java.util.List;
class ImmutableSet<T>
{
}
public class ParametersTest
{
public static void main(String[] args)
{
List<String> list0 = null;
List<String> list1 = null;
of(list0, list1);
}
@SuppressWarnings("unchecked")
public static <E> ImmutableSet<E> of(E e1, E e2) {
return create(e1, e2);
}
public static <E> ImmutableSet<E> of(E... elements) {
return create(elements);
}
private static <E> ImmutableSet<E> create(E... elements)
{
return null;
}
}
The call to of
in the main method is fine: It matches the 2-args-version of the of
method. Now comment out the 2-args-version of the of
-method. Then the call is still OK, but will directly invoke the varags version. This will cause a generic array to be created, and cause a warning. (This warning is suppressed in the 2-args-version, obviously).
So to summarize, I assume that this is in order to avoid warnings for clients of the library who want to invoke the of
method with several objects of a generic type.
Fortunately, things like this will no longer be necessary in the future, thanks to http://docs.oracle.com/javase/7/docs/api/java/lang/SafeVarargs.html