Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Overview

In Java, arrays are a fundamental part of the language, providing a structured way to store multiple values of the same type. However, when working with arrays and type casting, we sometimes encounter unexpected runtime exceptions.

One such issue arises when we attempt to cast an Object[] array to a specific array type, such as Integer[]. This results in a ClassCastException, which can confuse many of us.

In this tutorial, we’ll explore why this happens, understand the underlying mechanics of Java arrays, and learn how to avoid such errors in our code.

2. Introduction to the Problem

As usual, let’s first understand the issue through an example:

Integer[] convertObjectArray() {
    Object[] objArray = new Object[3];
    objArray[0] = 1;
    objArray[1] = 2;
    objArray[2] = 3;
    return (Integer[]) objArray;
}

We inserted three int values into an Object[] array in the above method. Since the Object[] array only contains integers, we attempt to convert it to an Integer[] array.

We can call this method in a test to see what will happen:

Exception ex = assertThrows(ClassCastException.class, () -> convertObjectArray());
LOG.error("The exception stacktrace:", ex);

As we can see, calling this method raises ClassCastException. Also, in the output, we can see the exception details:

java.lang.ClassCastException: class [Ljava.lang.Object; cannot be cast to class [Ljava.lang.Integer; ...
     at ...
     at ...
     ...

The message is pretty straightforward. It says we cannot cast the Object[] array to an Integer[] array, although all elements in the array are Integers. Next, let’s understand why this issue occurs.

3. Why Does This Exception Occur?

To understand why this happens, we need to examine the behavior of arrays in Java, particularly array covariance and runtime type checking.

Covariance means that a subclass type can be substituted for its parent type in certain situations. In Java, arrays are covariant, meaning that an array of a subclass (Integer[]) can be assigned to an array of its superclass (Object[]).

This feature allows us to do something like this:

Object[] objArray = new Integer[5]; // Valid, because Integer[] is a subtype of Object[]
objArray[0] = 42; // Allowed, since 42 is an Integer

However, this doesn’t mean we can freely cast Object[] to Integer[]. The actual array type remains Object[], and Java doesn’t allow treating it as Integer[] at runtime.

Therefore, this attempt fails:

(Integer[]) objArray

At this point, Java checks if objArray is actually an Integer[]. Since its actual runtime type is Object[], the cast fails, resulting in a ClassCastException.

4. Resolving the Issue

Now that we understand why the problem occurs, let’s figure out how to solve it.

4.1. Using an Integer[] Array Directly

The best way to avoid this issue is to initialize an array with the correct type from the beginning. In our example, instead of creating an Object[] array, we can create an Integer[] array if we plan to store Integer values:

Integer[] getIntegerArray() {
    Integer[] intArray = new Integer[3];
    intArray[0] = 1;
    intArray[1] = 2;
    intArray[2] = 3;
    return intArray;
}

A simple test can verify it works as expected:

assertArrayEquals(new Integer[] { 1, 2, 3 }, getIntegerArray());

Initializing an array with the desired type saves unnecessary conversions. However, we often receive Object[] arrays from other libraries or APIs. In this case, we cannot initialize the array from the beginning. Next, let’s see how to convert an Object[] array to an Integer[] array.

4.2. Stream-Based Conversion

We can leverage Stream API to convert Object[] to Integer[]:

Integer[] objArrayToIntArrayByStream() {
    Object[] objArray = new Object[] { 1, 2, 3 };
    Integer[] intArray = Stream.of(objArray).toArray(Integer[]::new);
    return intArray;
}

In this example, toArray(Integer[]::new) collects the elements from the stream into a new Integer[] array. Let’s test it:

assertArrayEquals(new Integer[] { 1, 2, 3 }, objArrayToIntArrayByStream());

This approach does the job, but we must be careful with type safety. We need to ensure that all elements in the Object[] are Integer instances. Otherwise, we may encounter ClassCastException when it converts any non-Integer element to Integer.

4.3. Loop-Based Conversion

Alternatively, we can easily convert an Object[] array to an Integer[] array by a for loop:

Integer[] objArrayToIntArray() {
    Object[] objArray = new Object[]{ 1, 2, 3 };
    Integer[] intArray = new Integer[objArray.length];
    for (int i = 0; i < objArray.length; i++) {
        intArray[i] = (Integer) objArray[i];
    }
    return intArray;
}

This method solves the problem by reading each element from the Object[] array and adds it to the target Integer[] array in a loop:

assertArrayEquals(new Integer[] { 1, 2, 3 }, objArrayToIntArray());

Similarly, if Object[] contains non-Integer elements, ClassCastException may raise.

4.4. Creating a Generic Conversion Method

We can extend the loop-based conversion method to a generic method, so that we can convert an Object[] array to any typed array (T[]). Next, let’s look at how to implement such a method:

<T> T[] convertFromObjectArray(Class<T> clazz, Object[] objArray) {
    T[] targetArray = (T[]) Array.newInstance(clazz, objArray.length);
    for (int i = 0; i < objArray.length; i++) {
        if (clazz.isInstance(objArray[i])) {
            targetArray[i] = clazz.cast(objArray[i]);
        } else {
            throw new ClassCastException("Element #" + i + ": Cannot cast " + objArray[i].getClass()
              .getName() + " to " + clazz.getName());
        }
    }
    return targetArray;
}

In this implementation, we first initialized a generic array. Then, we explicitly check each element before casting and throw a well-defined ClassCastException with a clear message.

Now, we can use this method to convert an Object[] to an array of different types:

assertArrayEquals(new Integer[] { 1, 2, 3 }, convertFromObjectArray(Integer.class, new Object[] { 1, 2, 3 }));
assertArrayEquals(new String[] { "I'm Kai", "I'm Liam", "I'm Kevin" },
  convertFromObjectArray(String.class, new Object[] { "I'm Kai", "I'm Liam", "I'm Kevin" }));

Of course, in case the input Object[] array contains elements in mixed types, the ClassCastException will be thrown:

Exception ex = assertThrows(ClassCastException.class, () -> convertFromObjectArray(String.class, new Object[] { "I'm Kai", Instant.now(), "I'm Kevin" }));
assertEquals("Element #1: Cannot cast java.time.Instant to java.lang.String", ex.getMessage());

As the test shows, the ClassCastException has a meaningful message, which helps debug and identify which specific element caused the issue.

5. Conclusion

In this article, we’ve discussed why the ClassCastException is raised when casting Object[] to Integer[] in Java. We also explored a few approaches to solving this issue through examples.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW