Question: Why can't I create an array of List ?

```
List<String>[] nav = new List<String>[] { new ArrayList<String>() };

```

Eclipse says "Cannot create a generic array of List"

or

```
ArrayList<String>[] nav = new ArrayList<String>[] { new ArrayList<String>() };

```

Eclipse says "Cannot create a generic array of ArrayList"

or

```
List<String>[] getListsOfStrings() {
    List<String> groupA = new ArrayList<String>();
    List<String> groupB = new ArrayList<String>();
    return new List<String>[] { groupA, groupB };
}

```

But I can do this:

```
List[] getLists() {
    return new List[] { new ArrayList(), new ArrayList() };
}

```

Eclipse says that List and ArrayList are *raw types* but it compiles...

Seems pretty simple, why won't it work?

Answer: 
Well, [generics tutorial](http://docs.oracle.com/javase/tutorial/extra/generics/fineprint.html) give the answer to your question.

> 
> The component type of an array object
>  may not be a type variable or a
>  parameterized type, unless it is an
>  (unbounded) wildcard type.You can
>  declare array *types* whose element type
>  is a type variable or a parameterized
>  type, but not array *objects*.
> 
> 
> This is
>  annoying, to be sure. This restriction
>  is necessary to avoid situations like:
> 
> 
> 
> ```
> // Not really allowed.
> List<String>[] lsa = new List<String>[10];
> Object o = lsa;
> Object[] oa = (Object[]) o;
> List<Integer> li = new ArrayList<Integer>();
> li.add(new Integer(3));
> // Unsound, but passes run time store check
> oa[1] = li;
> 
> // Run-time error: ClassCastException.
> String s = lsa[1].get(0);
> 
> ```
> 
> If arrays of parameterized type were
>  allowed, the previous example would
>  compile without any unchecked
>  warnings, and yet fail at run-time.
>  We've had type-safety as a primary
>  design goal of generics.
> 
> 
>
You can't create arrays of generic types, generally.

The reason is that the JVM has no way to check that only the right objects are put into it (with ArrayStoreExceptions), since the difference between `List<String>` and `List<Integer>` are nonexistent at runtime.

Of course, you can trick the compiler by using the raw type `List` or the unbound wildcard type `List<?>`, and then cast it (with a unchecked cast) to `List<String>`. But then it is your responsibility to put only `List<String>` in it and no other lists.