Map<Thread.State, V> mapping = new EnumMap<Thread.State, V>(Thread.State.class);

Object
  |
  +--- Collection<T>
          |
          +--- StringCollection
 
interface StringCollection extends Collection<String> {}

Generics are implemented by erasure, this means thta they enforce their type constraints only at compile time and discard their type information at runtime. This allows generic code to interoperate with the legacy code that doesn't use generics.

On the other hand arrays in contrast to generics are reified - arrays known and ensure their element types at runtime - an attempt to insert an instance of incompatible class to an array will result in the ArrayStoreException. That's why Java prohibites creation of the generic arrays (contract of an array will be violated). This means that you must know the class of the array elements to create new array cleanly/safely (without compilation warnings or possible problems at runtime).

So the obvious solution to your problem is to provide type information explicitly (approach taken by core Java libraries). Fortunately there is common idiom of using class literal (Class object) to pass such information. When you use such class literal among methods it is called type token. Once you have added this token you have full information that is needed to create an array:
public <T> T[] createEmptyArray(Class<T> type, int size){
return (T[]) Array.newInstance(type, size);
}
or
public T[] createEmptyArray(int size){
return (T[]) Array.newInstance(type, size);
}
if you will pass type token to the constructor/factory method and save it in the instance field.

If for any reason it is not possible consider following possibilites:

1. Use List instead of array - this will allow you to create new List without actual type of the formal parameter and you will also ommit compiler warning.
   public <T> List<T> createEmptyList(int initialSize){
   return new ArrayList<T>(initialSize);
   }
2. If and only if you need an array anyway and there is no way to provide type information explictly. You can benefict from the facts that arrays are covariant. This means that if type A is a subtype of type B then the array type A[] is subtype of B[] (e.g. Integer[] is a subtype of Number[] which is subtype of Object[]). With this in mind you can fake array creation by creating "super" array and then cast it to the type T[]. Ofcourse compiler will generate warning which you can suppress, but this already indicates that the operation is not type safe and the result array may not fullfil contract of the array in certain circumstances (e.g. it will be possible to insert wrong objects into array without ArrayStoreException). Which "super" array to create depends on whether your type parameter is bounded or unbounded. In the later case you will have to use Object[] since T can stand for any type. This is the worst case because it will be possible to store any object in the result array:
   GenericClass<String> stringHolder=new GenericClass<String>();
   String[] strArr = stringHolder.createEmptyArray(1); // Creates new Object[] array
   Object[] objArr = strArr; // Always legal, arrays are covariant
   objArr[0] = Boolean.TRUE; // Succeeds
   In the case of bounded type parameter you should create array of the bound type (e.g. in your example this would be Number[] since parameter T has type Number as the upper bound). This approach will be a bit safer and at least it will fail in some cases at runtime:
   GenericClass<Integer> stringHolder=new GenericClass<Integer>();
   Integer[] intArr = stringHolder.createEmptyArray(1); // Creates new Number[] array
   Number[] numArr = intArr; // Always legal, arrays are covariant
   numArr[0] = Boolean.TRUE; // Fails at runtime with ArrayStoreException
   numArr[0] = Double.NaN; // Succeeds
   

Conclusions: avoid arrays. If you need them provide type information explicitly when array must be created. If you can't provide such information you can create array of Object[] or array of the "bound" type and then return it by casting to the formal parameter array (e.g. T[]).

I hope this information will be helpful for you!

P.S. You can find more information on the topic here:

• Chapter 5 of the "Effective Java Second Edition" book
• Generics tutorial