Post History

I'm afraid there's no easy, straighforward way to do that. Due to type erasure, we don't have enough information to create the array directly. Therefore, this information must be provided somehow.

# Alternative 1: `Class` object informed in the constructor

You could force all instances of `ExampleClass` to be created with a `Class<S>` object:

```java
import java.lang.reflect.Array;

public class ExampleClass<S extends SomeClass> {
    private Class<S> arrayClass;
    public ExampleClass(Class<S> arrayClass) {
        this.arrayClass = arrayClass;
    }

    public S[] createArray(int n) {
        return (S[]) Array.newInstance(arrayClass, n);
    }
}
```

I admit it might be annoying to provide a `Class` object for every new instance of `ExampleClass`. But now it works:

```java
ExampleClass<SomeSubClass> creator = new ExampleClass<>(SomeSubClass.class);
SomeSubClass[] array = creator.createArray(10);
```

Assuming, of course, that `SomeSubClass` is a subclass of `SomeClass`.

---

### But what if `SomeSubClass` is also generic?

Let's say `SomeSubClass` also has a generic type:

```java
// parent class, not generic
class SomeClass {
}
// subclass, generic
class SomeSubClass<T> extends SomeClass {
}
```

And I want to create an array of `SomeSubClass<String>`. Unfortunately, passing just `SomeSubClass.class` doesn't compile. Trying something like `SomeSubClass<String>.class` doesn't compile either. And a cast such as `(Class<SomeSubClass<String>>) SomeSubClass.class` also doesn't compile. So you need to do this trick:

```java
ExampleClass<SomeSubClass<String>> creator = new ExampleClass<>((Class<SomeSubClass<String>>) (Class<?>) SomeSubClass.class);
```

Yes, it's ugly, but it works: now `createArray` will return an array of `SomeSubClass<String>`.

---

# Alternative 2: varargs

Another way to solve it is to change the method to receive a varargs argument of the desired type:

```java
import java.util.Arrays;

public class ExampleClass<S extends SomeClass> {
    public S[] createArray(int length, S... elements) {
        return Arrays.copyOf(elements, length);
    }
}
```

This solution provides information about the type in the varags `elements`, so that `Arrays.copyOf` can create an array of the correct type.

With this, you don't need to provide a `Class` object anymore, which makes it less cumbersome, specially if the type is also generic (no need to do the ugly cast trick):

```java
// No need to provide a Class object
// It works even if SomeSubClass is a generic type
ExampleClass<SomeSubClass<String>> ec = new ExampleClass<>();
SomeSubClass<String>[] array = ec.createArray(5);
```

Due to vargs, the `elements` argument is optional, so passing just the size will set all elements to `null`, just like it happens when you create a new array with `new Type[size]`.

As a bonus, you can also initialize some of (or all) the elements of the array:

```java
// first and seconds elements will be set to instance1 and instance2, respectively
// the other elements will be null
SomeSubClass<String>[] array = ec.createArray(5, instance1, instance2);
```