What does <E> mean in Collection<E>?

Question

What meaning has <E> on the code Collection<E>?

Answer 1

It's the use of generics. Check this intro out. And then don't forget to read this tutorial.

An excerpt follows (which compares the use of a cast versus the use of generics):

When you see the code <Type>, read it as “of Type”; the declaration above reads as “Collection of String c.” The code using generics is clearer and safer. We have eliminated an unsafe cast and a number of extra parentheses. More importantly, we have moved part of the specification of the method from a comment to its signature, so the compiler can verify at compile time that the type constraints are not violated at run time. Because the program compiles without warnings, we can state with certainty that it will not throw a ClassCastException at run time. The net effect of using generics, especially in large programs, is improved readability and robustness.

For example, the interface of a List is

public interface List<E> { 
    void add(E x);
    Iterator<E> iterator();
}

This means you can build a list whose contents are all of the same explicit type (not only of type Object), even if you have defined the type yourself. So, if you create a Name class you can write

List<Name> nameList = new List<Name>();

and then fill it with Name instances and directly retrieve Name instances from it without having to cast or otherwise worry about it because you'll always get either a Name instance or null back, never an instance of a different type.

More importantly, you cannot insert anything different from a Name instance in such a List, because it will fail at compile time.

nameList.add(false); //Fails!
nameList.add(new Name("John","Smith")); //Succeeds supposing Name has a 
                                        //firstName, lastName constructor

Answer 2

It means that you're dealing with a collection of items with type E. Imagine you've got a cup of tea. Instead of tea, it could also hold coffee so it makes sense to describe the cup as a generic entity:

class Cup<T> { … }

now you could fill it, either with coffee or tea (or something else):

Cup<Tea> cuppa = new Cup<Tea>();
Cup<Coffee> foamee = new Cup<Coffee>();

In order for this to work, both Tea and Coffee would need to be types defined in your program as well.

This is a compile-time constraint on your code. Coming back from the (rather useless) cup example, collections (arrays, lists …) usually contain items of one type, e.g. integers or strings. Generics help you to express this in Java:

Collection<String> strList = new ArrayList<String>();
strList.add("Foobar"); // Works.
strList.add(42);       // Compile error!

Notice the compile error above? You only get this when using generics. The following code also works, but would not give the nice error message:

Collection strList = new ArrayList();
strList.add("Foobar"); // Works.
strList.add(42);       // Works now. Do we really want this?!