Why array instantiation with a generic type does not work in Java?

Question

public interface Foo<E> {

    public void blah(E e);

}

public class MyClass<E> {

    private final Foo<E>[] fooArray = new Foo<E>[8]; // does not compile!

    // (...)

}

What is the correct way of addressing that generics limitation?

Or maybe it is not a limitation and I am missing something?

What if you try "new Foo[8]" to see what happens? Your instantiation will need to be concrete. — James Black, Jun 13 '14 at 15:10
@JamesBlack if you try `new Foo[8]` you'll still get a compile error — Nick Holt, Jun 13 '14 at 15:17
@chrisapotek do not add such things like *this is not a duplicate* in question, that kind of edits just enrage users. — Luiggi Mendoza, Jun 13 '14 at 15:17
It is a duplicate because its still being caused by the same fundamental problem but I'm not going to fight you over it. The real moral of this story is that arrays and generics do not play well together. Better to use collections. — Tim B, Jun 13 '14 at 15:19
See [Array of Generic Interface](http://stackoverflow.com/a/3975913/). — MicSim, Jun 13 '14 at 15:21
Possible way around would be creating `class FooE extends Foo{}` and use it like `FooE[] fooArray = new FooE[8];` but that should be really last resort. Preferred way would be using `List>` — Pshemo, Jun 13 '14 at 15:41

Luiggi Mendoza · Answer 1 · 2014-06-13T15:29:05.120

2

The make-it-compile way would be declaring the variable using generics but initializing the array (not the elements) using raw type:

//add @SuppressWarnings("unchecked") to avoid warnings
Foo<String>[] arrayOfFoo = new Foo[8];
arrayOfFoo[0] = new ClassThatImplementsFoo<String>();
//line below gives a compile error since the array declaration is for Foo<String>
//and won't allow Foo<AnotherClass>
arrayOfFoo[1] = new ClassThatImplementsFoo<Integer>();

A better and safer approach would be using List instead of plain array:

List<Foo<String>> fooList = new ArrayList<Foo<String>>();
fooList.add(new ClassThatImplementsFoo<String>());

In your code, you should do this:

public class MyClass<E> {
    private final Foo<E>[] fooArray = new Foo[8];
    // (...)
}

edited Jun 13 '14 at 15:29

answered Jun 13 '14 at 15:11

Luiggi Mendoza

85,076
16
154
332

The raw type approach is inherently bad (you should never use raw types). The list approach is better. I wouldn't label the first one as "correct". – arshajii Jun 13 '14 at 15:12
I do NOT know the type in advance. See my edit! – chrisapotek Jun 13 '14 at 15:13
@arshajii sadly, Java doesn't provide another compilable way to **initialize** the array. Note that the elements in the array cannot be initialized as `ClassThatImplementsFoo` or another object. – Luiggi Mendoza Jun 13 '14 at 15:13
@chrisapotek the solution applies as well if you use generics. Try it first. – Luiggi Mendoza Jun 13 '14 at 15:14
@LuiggiMendoza Your suggestion gives a warning (rawtype). Is that normal, expected? – chrisapotek Jun 13 '14 at 15:33
@chrisapotek I explained in my answer how to avoid the warning (that only notifies you're using a raw type). Seriously, seems that you only read the code and not the content of the answer. – Luiggi Mendoza Jun 13 '14 at 15:34
Is your explanation to suppress de warning with the annotation? – chrisapotek Jun 13 '14 at 17:03

Why array instantiation with a generic type does not work in Java?

1 Answers1