Container of Generic Types in java

Question

I have a generic class Foo<T> and parameterized types Foo<String> and Foo<Integer>. Now I want to put different parameterized types into a single ArrayList. What is the correct way of doing this?

Candidate 1:

public class MMM {
    public static void main(String[] args) {
        Foo<String> fooString = new Foo<String>();
        Foo<Integer> fooInteger = new Foo<Integer>();

        ArrayList<Foo<?> > list = new ArrayList<Foo<?> >();
        list.add(fooString);
        list.add(fooInteger);

        for (Foo<?> foo : list) {
            //  Do something on foo.
        }
    }
}
class Foo<T> {}

Candidate 2:

public class MMM {
    public static void main(String[] args) {
        Foo<String> fooString = new Foo<String>();
        Foo<Integer> fooInteger = new Foo<Integer>();

        ArrayList<Foo> list = new ArrayList<Foo>();
        list.add(fooString);
        list.add(fooInteger);

        for (Foo foo : list) {
            //  Do something on foo.
        }
    }
}
class Foo<T> {}

In a word, it is related to the difference between Foo<?> and the raw type Foo.

Update:

Grep What is the difference between the unbounded wildcard parameterized type and the raw type? on this link may be helpful.

Answer 1

List represents a list with no type parameter. It is a list whose elements are of any type, e.g. the elements may be of different types. It's basically the same as List<Object>.

Meanwhile, List<?> represents a list with an unbounded type parameter. Its elements are of a specific, but unknown (before runtime), type. These elements all have to be from the same type at Runtime.

I recommend avoiding using raw types. The proper solution for your example is List<Foo<?>>.

Answer 2

You want to avoid raw types whenever possible. The correct way to do it would be with
List<Foo<?>>.