Creating array of generic object

Question

hello, what i want to do is something like:
public class AClass<K extends SomeObject>{
    SomeObject[] AnArray;
    public void amethod() {
        AnArray=new K[10];
}So I want to create an array of some kind of object at runtime without already know the kind of the object. The thing is that I think that generics are only "known" at compiling time, so this AnArray=new K[10]; is propably completely wrong but I cannot think of any other way of creating an array without knowing in advance the kind of object....So if someone could enlighten me on how to do this...
if this is of any help the reason i want to have such implementation is that this array is supposed to be a hashmap and the SomeObject is supposed to be a super class of some different kind of LinkedList classes, so I want the hashmap to be flexible on what kind of list will be used. Suggestions for completely different approach are also welcome offcourse, but I would prefer it if someone could give some brief explaination on how manipulating such a generic array issue...

Answer 1

Hi Fraksia,
Unfortunately, array creation of type parameters is not allowed, so you can't
say new T[3]; That is because T doesn't exist at compile time. It is erased.
It is misleading - I know. Because when you say
AClass<SomeObject> aclass=new AClass<SomeObject>();you might thing that T becomes SomeObject in your class wheres
what that does is that whenever you expect your type parameter in
the calling code, compiler will insert a cast. See the example below:
class MyClass<T> {
   T o;
   public MyClass(T o) {
      this.o=o;
   public T get() {
      return o;
class CallingClass {
   public static void main(String[] args) {
      MyClass<String> m=new MyClass<String>("Test");
      String o=m.get();  //no cast needed here
}Benefit: increased type safety, no casts needed in the CallingClass.
What really happens is:
class MyClass {
   Object o;
   public MyClass(Object o) {
      this.o=o;
   public Object get() {
      return o;
class CallingClass {
   public static void main(String[] args) {
      MyClass m=new MyClass("Test);
      String s=(String)m.get();  // compiler inserts cast here based on your type parameter
}That is why you can't do what you wanted - because "there is no spoon" ;)
Generics in Java are only a compile time feature.
Cheers,
Adrian