84

What's wrong with the following code?

Object[] a = new Object[1];
Integer b=1;
a[0]=b;
Integer[] c = (Integer[]) a;

The code has the following error at the last line :

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;

5 Answers 5

115

Ross, you can use Arrays.copyof() or Arrays.copyOfRange() too.

Integer[] integerArray = Arrays.copyOf(a, a.length, Integer[].class);
Integer[] integerArray = Arrays.copyOfRange(a, 0, a.length, Integer[].class);

Here the reason to hitting an ClassCastException is you can't treat an array of Integer as an array of Object. Integer[] is a subtype of Object[] but Object[] is not a Integer[].

And the following also will not give an ClassCastException.

Object[] a = new Integer[1];
Integer b=1;
a[0]=b;
Integer[] c = (Integer[]) a;
Sign up to request clarification or add additional context in comments.

4 Comments

Why does Arrays.copyOf never throw a ClassCastException?
Because in there I give the Integer[].class as the parameter. I suppose internally, each object will convert to Integer and added to the Integer array
Yeah well typically one encounters this when working with generics, where this answer is useless.
If you have an array like this --> Object[] a = {1, 2, "b", 'c'}; then you'll get an error saying "element type mismatch..."
28

You can't cast an Object array to an Integer array. You have to loop through all elements of a and cast each one individually.

Object[] a = new Object[1];
Integer b=1;
a[0]=b;
Integer[] c = new Integer[a.length];
for(int i = 0; i < a.length; i++)
{
    c[i] = (Integer) a[i];
}

Edit: I believe the rationale behind this restriction is that when casting, the JVM wants to ensure type-safety at runtime. Since an array of Objects can be anything besides Integers, the JVM would have to do what the above code is doing anyway (look at each element individually). The language designers decided they didn't want the JVM to do that (I'm not sure why, but I'm sure it's a good reason).

However, you can cast a subtype array to a supertype array (e.g. Integer[] to Object[])!

2 Comments

The fact that arrays are covariant means that the JVM already has to check for type safety when it performs assignments - but not when it just reads an element.
The reason is pretty simple. If you were allowed to cast an Object[] to Integer[], then the JVM could never be sure of the actual type of the objects in the array, since old references to the array as an Object[] might still exist. It would have to typecheck every access of an object in an array, every time, since it would never know for sure what it was. And if the type check failed, it would throw an exception somewhere completely different from where the cause was.
15

Or do the following:

...

  Integer[] integerArray = new Integer[integerList.size()];
  integerList.toArray(integerArray);

  return integerArray;

}

3 Comments

Is this integerArray which is Integer[] equal to int[] ? I guess it is not. Need to do unboxing.
Only works if integerList is a List or an ArrayList.. not for "classic" Arrays tho :(
you could also use Arrays.asList(objectArray).toArray(new Integer[objectArray.length]), but then, this does exactly the same as namalfernandolk's answer with unneccessary overhead
5
java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;

you try to cast an Array of Object to cast into Array of Integer. You cant do it. This type of downcast is not permitted.

You can make an array of Integer, and after that copy every value of the first array into second array.

Comments

1
When casting is done in Java, Java compiler as well as Java run-time check whether the casting is possible or not and throws errors in case not.

When casting of Object types is involved, the instanceof test should pass in order for the assignment to go through. In your example it results
Object[] a = new Object[1]; boolean isIntegerArr = a instanceof Integer[]
If you do a sysout of the above line, it would return false;
So trying an instance of check before casting would help. So, to fix the error, you can either add 'instanceof' check
OR
use following line of code:
(Arrays.asList(a)).toArray(c);

Please do note that the above code would fail, if the Object array contains any entry that is other than Integer.

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.