How can I create an array of items whose entries have generic fields?

Question

I have this code:

import java.util.*;
import java.lang.*;
import java.io.*;

class Main{
    public static void main (String[] args){
        Foo<String> foo = new Foo<String>(1000);
    }
}

class Foo<Key extends Comparable<Key>>{
    private Entry[] a;
    private class Entry{
        Key key;
    }
    public Foo(int size){
        a = (Entry[])new Object[size]; // <- this is the problem
    }
}

when I compile it, I get an error, saying:

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [LFoo$Entry;
at Foo.<init>(Main.java:17)
at Main.main(Main.java:7)

I tried:

import java.util.*;
import java.lang.*;
import java.io.*;

class Main{
    public static void main (String[] args){
        Foo<String> foo = new Foo<String>(1000);
    }
}

class Foo<Key extends Comparable<Key>>{
    private Entry[] a;
    private class Entry{
        Key key;
    }
    public Foo(int size){
        a = new Entry[size];
    }
}

But then I got an error saying:

Main.java:17: error: generic array creation
        a = new Entry[size];
            ^

Is it possible to create that array at all?

score 1 · Answer 1 · edited May 23 '17 at 12:06

1

It because Generics don't cope very well with arrays (at compile-time).

You should rather use some Collection, instead:

class Foo<Key extends Comparable<Key>> {
    private List<Entry> a;

    private class Entry {
        Key key;
    }

    public Foo(int size) {
        a = new ArrayList<Entry>(size);
    }
}

edited May 23 '17 at 12:06

Community

1
1

answered Jul 29 '15 at 13:55

Konstantin Yovkov

62,134
8
100
147

What about `java.lang.reflect.Array.newInstance` ? – Andremoniy Jul 29 '15 at 13:59
Yes, the approach with Reflection is nice, but I'd rather use a Collection, instead of doing such workarounds. :) – Konstantin Yovkov Jul 29 '15 at 14:00
May be he *must* use arrays, we don't know – Andremoniy Jul 29 '15 at 14:01

score 1 · Accepted Answer · answered Jul 29 '15 at 13:58

1

Well, actually you can via reflection:

public class Main {
    public static void main(String[] args) {
        Foo<String> foo = new Foo<String>(1000);
        foo.a[0] = foo.new Entry();
        foo.a[0].key = "ss";
    }
}

class Foo<Key extends Comparable<Key>> {
    public Entry[] a;

    public class Entry {
        Key key;
    }

    public Foo(int size) {
        a = (Entry[]) java.lang.reflect.Array.newInstance(Entry.class, size);
    }
}

answered Jul 29 '15 at 13:58

Andremoniy

34,031
20
135
241

Why can't java do this by default? Sounds like a pain to have to cast and write this long winded method call. – Pavel Jul 29 '15 at 14:48
you can always do `import java.lang.reflect;` and write simple `...Array.newInstance(...` – Andremoniy Jul 30 '15 at 12:28

MadConan · Answer 3 · 2015-07-29T14:04:32.020

1

I agree with kocko that you should use some Collection instead of arrays. But specifically to your point, this compiles and runs for me. This just pushes off the responsibility for creating the array to the Array.newInstance method. The downside is it forces the cast

 class Foo<Key extends Comparable<Key>>{
     private Entry[] a;
     private class Entry{
       Key key;
     }
     public Foo(int size){
       a = (Entry[])Array.newInstance(Entry.class,size);
     }
}

edited Jul 29 '15 at 14:04

answered Jul 29 '15 at 14:00

MadConan

3,749
1
16
27

@Andremoniy Story of my life. :P – MadConan Jul 29 '15 at 14:05

Sotirios Delimanolis · Answer 4 · 2015-07-29T15:26:55.930

Being an inner class, the Entry type is within the scope of the type parameter Key declared in the enclosing class. In other words, Entry is also generic.

You can use

a = (Entry[]) new Foo<?>.Entry[size];

or the raw equivalent (which I don't recommend)

a = (Entry[]) new Foo.Entry[size];

This type of array creation is explained in the JLS

ArrayCreationExpression:
    new ClassOrInterfaceType DimExprs [Dims]

stating

It is a compile-time error if the ClassOrInterfaceType does not denote a reifiable type (§4.7).

where a reifiable type is

A type is reifiable if and only if one of the following holds:

It refers to a non-generic class or interface type declaration.

It is a parameterized type in which all type arguments are unbounded wildcards (§4.5.1).

It is a raw type (§4.8).

It is a primitive type (§4.2).

It is an array type (§10.1) whose element type is reifiable.

It is a nested type where, for each type T separated by a ".", T itself is reifiable.

By using the parameterization with a wildcard or the raw type, we can get the array creation expression presented above.

How can I create an array of items whose entries have generic fields?

4 Answers4