Explain the syntax of Collections.<String>emptyList()

Solution 1:

That line creates an empty list of strings by calling a static method with a generic type parameter.

Inside the Collections class, there is a static method emptyList declared like:

public static final <T> List<T> emptyList() {
    return (List<T>) EMPTY_LIST;
}

This has a generic type parameter T. We call call this method by using:

List<String> list = Collections.emptyList();

and T is infered to be a String because of the type of list.

We can also specify the type of T by putting it in angle brackets when calling emptyList. This may be needed if we want a more specific type than is inferred:

List<? extends Object> list = Collections.<String>emptyList();

emptyList<String>() is not correct because that placement is only valid when creating instances of generic classes, not calling methods. When using new there are two possible type parameters, the ones before the class name are for the constructor only, and the ones after the class name are for the whole instance, so with the class:

class MyClass<A> {
    public <B> MyClass(A a, B b) {
        System.out.println(a + ", " + b);
    }
}

We can call its constructor where A is String and B is Integer like:

MyClass<String> a = new <Integer>MyClass<String>("a", 3);

or by using type inference:

MyClass<String> a = new MyClass<>("a", 3);

See also:

• Generic Methods
• Type Inference

Solution 2:

What is Collections? Why isn't it Collections<E> or Collections<String>?

Collections is a JDK class.

This class consists exclusively of static methods that operate on or return collections. It contains polymorphic algorithms that operate on collections, "wrappers", which return a new collection backed by a specified collection, and a few other odds and ends.

It's not generic and cannot be instantiated.

Why is <String> placed before the method name emptyList?

Collections#emptyList is a generic method. Here, we are explicitly specifying a type argument, String.

(Isn't emptyList<String>() correct for Generic?)

No, in Java, generic type arguments for methods come before the method name.

What does the statement mean?

We are invoking the static emptyList method and assigning its return value to a variable of type List<String>.

Solution 3:

In a nutshell, this creates an empty, immutable list of strings.

Let's look at the expression bit by bit.

Collections is the name of a class. From the Javadoc:

This class consists exclusively of static methods that operate on or return collections. It contains polymorphic algorithms that operate on collections, "wrappers", which return a new collection backed by a specified collection, and a few other odds and ends.

emptyList() is the name of a static method defined in the Collections class (Javadoc). It is a generic method, and the <String> in Collections.<String>emptyList() specifies the generic type argument.

The method returns a List<T>, which in this case is List<String>: a list of strings. More specifically, it returns an empty, immutable list of strings.