访问Object []类型的数组时发生ClassCastException

Question

Please consider the following piece of Java code (I have taken it from real world but simplified a bit and removed irrelevant details):

public class CastIssue<T> {
  @SuppressWarnings("unchecked")
  private T[] data = (T[]) new Object[1];

  public static void main(final String[] args) {
    final CastIssue<Integer> issue = new CastIssue<>();
    System.out.println(issue.data.length);
  }
}

It compiles fine but throws the following exception when executed:

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;
    at CastIssue.main(CastIssue.java:7)

On the other hand if I add explicit cast to Object[] it works without exception:

public class CastIssue<T> {
  @SuppressWarnings("unchecked")
  private T[] data = (T[]) new Object[1];

  public static void main(final String[] args) {
    final CastIssue<Integer> issue = new CastIssue<>();
    System.out.println(((Object[])issue.data).length);
  }
}

Why does exception is thrown in the first case?

I use JDK 1.8.0_40

EDIT: as noted by @wero, compiler inserts a cast in the first case. I want to understand why that cast is inserted there (sorry for not stating this explicitly in the original question). Any references to JLS or JVM specification would be good.

Answer 1

In the compiled class the type of the field private T[] data is Object[] due to type erasure. But when you access it ( issue.data.length in your first example) it is casted to a Integer array. This is easy to see when you decompile the class with javap :

  public static void main(java.lang.String[]);
    Code:
       0: new           #1                  // class test/CastIssue
       3: dup
       4: invokespecial #24                 // Method "<init>":()V
       7: astore_1
       8: getstatic     #25                 // Field java/lang/System.out:Ljava/io/PrintStream;
      11: aload_1
      12: getfield      #14                 // Field data:[Ljava/lang/Object;
      15: checkcast     #31                 // class "[Ljava/lang/Integer;"
      18: arraylength
      19: invokevirtual #33                 // Method java/io/PrintStream.println:(I)V
      22: return

When you cast it to an Object array (your second example), the checkcast operation is dropped and the error does not occur:

  public static void main(java.lang.String[]);
    Code:
       0: new           #1                  // class test/CastIssue
       3: dup
       4: invokespecial #24                 // Method "<init>":()V
       7: astore_1
       8: getstatic     #25                 // Field java/lang/System.out:Ljava/io/PrintStream;
      11: aload_1
      12: getfield      #14                 // Field data:[Ljava/lang/Object;
      15: arraylength
      16: invokevirtual #31                 // Method java/io/PrintStream.println:(I)V
      19: return    

Answer 2

Because of type erasure, T is actually an Object in the non-static methods of CastIssue . In the main method, T is known to be Integer , so the issue.data reference is implicitly cast to an Integer[] .

An Integer[] is a subclass of an Object[] , in the same way Integer is a subclass of an Object .

You can assign an Integer to a variable of type Object , but you cannot cast/assign an Object to a variable of type Integer .

Same goes for the arrays: You can assign an Integer[] to a variable of type Object[] , but you cannot cast/assign an Object[] to a variable of type Integer[] .

---

So, how do you do it, with generics?

In order for the code to construct an actual instance of T , or a T[] , it must be given the actual Class of whatever T is supposed to be at runtime.

You can pass in that class on the constructor, and use reflection to create the array:

private T[] data;

@SuppressWarnings("unchecked")
public CastIssue(Class<T> clazz) {
    this.data = (T[])Array.newInstance(clazz, 1);
}

Your main method will then be:

final CastIssue<Integer> issue = new CastIssue<Integer>(Integer.class);
System.out.println(issue.data.length);

Specifying Integer twice on the constructor seems redundant, and sure it can be collapsed with the diamond operator ( new CastIssue<>(Integer.class) ), but still...

You can use a generic static method to let the compiler infer the type ( T ) from the parameter:

public static <T> CastIssue<T> create(Class<T> clazz) {
    return new CastIssue<T>(clazz);
}

This way the main method becomes:

final CastIssue<Integer> issue = create(Integer.class);
System.out.println(issue.data.length);

Whether that's better is for you to decide.