实例化泛型类型ArrayList <T>

Question

I am new to generics and read in a article "A parameterized type, such as ArrayList<T> , is not instantiable — we cannot create instances of them".

Full quote, from Java in a Nutshell:

A parameterized type, such as ArrayList<T> , is not instantiable - we cannot create instances of them. This is because <T> is just a type parameter - merely a place-holder for a genuine type. It is only when we provide a concrete value for the type parameter, (eg, ArrayList<String> ), that the type becomes fully formed and we can create objects of that type.

This poses a problem if the type that we want to work with is unknown at compile time. Fortunately, the Java type system is able to accommodate this concept. It does so by having an explicit concept of the unknown type which is represented as <?> .

I understand that it should not be instantiable since the concrete (actual) type is not known. If so, why does the below code compiles without an error?

public class SampleTest {

    public static <T> List<T> getList(T... elements) {

        List<T> lst = new ArrayList<>(); // shouldn't this line return an error? 

        return lst;
    }
}

I know there is a gap in my understanding of generics here. Can someone point out what am i missing here?

Answer 1

Because T is given as another generic type argument.

It's the whole purpose of generics to make the type parameterizeable. So the caller can specify the type. This can be done in multiple layers: the caller may also be generic and let its caller specify the type.

public static void main(String[] args)
{
  foo(7);
}

public static <T> void foo(T value)
{
  bar(value);
}

public static <U> void bar(U value)
{
  baz(value);
}

public static <V> void baz(V value)
{
  System.out.println(value.getClass().getSimpleName());
}

It prints out

Integer

A parameterized type, such as ArrayList<T> , is not instantiable

Means: You cannot create ArrayList of an unknown T. It must be specified at compile time. But it can be done indirectly, by another generic. In your case, it's another T , which will be specified again by the caller of your generic getList .

---

The wildcard <?> is something different. It is used to specify compatibility. <?> is the syntax to avoid specification of the type. You can use extends to require a basetype or interface. However, you cannot create instances with wildcards.

  List<?> list = new ArrayList<String>();
  list = new ArrayList<Integer>();

This wouldn't be possible otherwise. It makes most sense when using it in parameter specifications, for instance:

  public static int foo(List<? extends Comparable> list)
  {
     return list.get(1).compareTo(list.get(2));
  }

It's very confusing of this book. It assumes that <?> somehow solves the problem that a List with unknown T cannot be instantiated. IMHO, this is rubbish. T must be specified to create an instance.

Answer 2

The code that you mention can compile because the Object "lst" is not actually initialized until the method is called. Since the method knows that it will be getting a var-args argument of type T, it can compile in this scenario. Take the example Wrapper class below for example:

public class Wrapper<T> {


    public static <T> List<T> getList(T... elements){
        List<T> lst = new ArrayList<>();
        for(T element: elements) {
            lst.add(element);
        }
        return lst;
}

}

This code can compile because the method hasn't been called. When the method is called, Type T will be the type that we pass as the var-args argument and the code will have no issue compiling. Lets test this in our main method:

 public static void main( String[] args ){

      System.out.println(Wrapper.getList("Hi", "Hello", "Yo"));

 }

And the output is:

[Hi, Hello, Yo]

However, lets generate a compile-time error to see what the article is talking about within our main method:

Wrapper<T> myWrap = new Wrapper<>();

We are actually trying initialize a generic Object of the Wrapper class in the code above, but is unknown. Since the value for the placeholder will be unknown even when we call the method, it results in a compile-time error, whereas creating a List of type T within the getList method does not cause a compile-time error because it will be initialized with a type when the method is called.

Answer 3

once you call the method -> you are using a concrete value.

the method defines T and later you use it in the return type and the parameter list.

public static <T> List<T> getList(T... elements)

once you will send the first parameter from specific type -> the contract will force you for the next parameters.

List<? extends Object> list = getList("", 1); -> in this case java doesnt find common between string and integer so it uses the most basic connection "Object"

List<String> list2 = getList("test", "test2"); -> here you can see that because all of the parameters are Strings - java find that in common and use it as the T.

Answer 4

The specific passage from the book doesn't make any sense and is wrong. new ArrayList<T>() is perfectly fine provided that we are in the scope of a type parameter named T (either a type parameter of a generic class that we are in, or a type parameter of the generic method we are in).

new ArrayList<T>() can no less be instantiated than new ArrayList<String>() -- both compile to the same bytecode and both just instantiate an ArrayList object at runtime. The object doesn't know anything about its type parameter at runtime, and therefore no knowledge of T at runtime is needed to instantiate it. The type parameter in an instantiation expression of a parameterized type ( new ArrayList<T> ) is just used by the compiler to type-check the parameters passed to the constructor (there are none in this case) and to figure out the type returned by the expression; it is not used in any other way.

And by the way the method does not need to receive any parameters of type T , or of any type containing T , in order for this to work. A method that receives no arguments can still instantiate and return an ArrayList<T> perfectly fine:

public static <T> List<T> emptyList() {
    List<T> lst = new ArrayList<T>();
    return lst;
}

Also, the section in the book where this statement appears in doesn't really have anything to do with instantiation -- the section is about wildcards, and wildcards don't really have anything to do with object instantiation at all. So I am not really sure why they are mentioning it (incorrectly) there.